omp-worklog 0.14.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d3b75162007b035e355c30a7709bef9b63523da3f81c469d89fc9749738fc22
+  data.tar.gz: 4c2b9cfff9e693c218e367a567222a0621a02a5537c7bee52e9b1af743e96716
+SHA512:
+  metadata.gz: 0eca9563cc7050108826e0b55996efa6b9300274e89358b0e62c59959c54b4d35630fbdbfda8910c9ca4f66db008901dda487c776821932bea1826b8bd1c5c80
+  data.tar.gz: 07ec72a2c85b3cfb91d5f536177a94a7307613ecda350c8bf5c15058e7dcf9f2db0a66127104d930f7a71191e8b37132f98438231e7953bb383e2737d79e149b

data/README.md

@@ -0,0 +1,137 @@
+# OMP Worklog
+
+OMP Worklog is a Project Time-driven Ruby CLI and OMP plugin that builds reviewable personal work logs from local evidence. Harvest is currently one manual destination: the only Harvest operations are explicitly requested time-off and ordinary-work writes.
+
+## Documentation
+
+The repository-local [knowledge base](docs/README.md) defines the product direction, domain, architecture, decisions, and QA boundaries. It distinguishes the provider-neutral work-log direction from the current Harvest-specific adapters.
+
+## Credentials
+
+1. Open [Harvest ID Developers](https://id.getharvest.com/developers) and create a Personal Access Token for this local tool.
+2. Harvest displays the token and the available Harvest account IDs once. Copy the account ID for the account to track time in.
+3. Fill the ignored `.envrc` in this repository:
+
+   ```bash
+   export HARVEST_ACCESS_TOKEN="your-personal-access-token"
+   export HARVEST_ACCOUNT_ID="your-harvest-account-id"
+   ```
+
+4. Run `direnv allow` if you use direnv; otherwise run `source .envrc` in the shell that starts OMP or the CLI.
+
+Personal Access Tokens are the intended Harvest authentication method for personal scripts. Revoke and replace a token from Harvest ID if it is exposed. [Harvest authentication documentation](https://help.getharvest.com/api-v2/authentication-api/authentication/authentication/).
+
+## CLI
+
+```text
+omp-worklog time-off FROM TO --project NAME --task NAME [options]
+omp-worklog time-off FROM TO --project-id ID --task-id ID [options]
+omp-worklog work-entry DATE --project NAME --task NAME --hours HOURS --notes NOTES [options]
+omp-worklog work-entry DATE --project-id ID --task-id ID --hours HOURS --notes NOTES [options]
+```
+
+### Time off
+
+The `time-off` command creates one 7-hour entry for each Yukon business day in an inclusive range. It skips weekends and observed Yukon holidays by default.
+
+```bash
+omp-worklog time-off 2026-08-17 2026-08-28 \
+  --project 'Time Off - Marlen' \
+  --task 'Vacation / PTO' \
+  --notes 'regular time off' \
+  --dry-run
+```
+
+The default holiday region is `ca_yt`. Add `--holiday-region REGION` or set `HARVEST_HOLIDAY_REGIONS` to include other [Holidays](https://github.com/holidays/holidays) regions. `business_time` calculates business days and `holidays` supplies observed statutory holidays.
+
+A time-off block never creates weekend entries. When names are supplied, it resolves them from your active personal Harvest assignments, so a Project Manager role is not required.
+
+The `omp_worklog_record_time_off` OMP tool accepts the same name pair or ID pair. Its optional `holidayRegions` array adds per-call regions to the configured defaults.
+
+### 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.
+
+### Project Time timesheets
+
+`/omp-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.
+
+Use `--project PROJECT` only to restrict the draft to one exact local Project Time project:
+
+```text
+/omp-worklog timesheet yesterday
+/omp-worklog timesheet yesterday --project wrap
+```
+
+A configured `projectTimeMappings` destination becomes the draft's Harvest `Project` and `Task`. Evidence with no mapping, an ambiguous work item, or an unassigned work item remains visible under its exact local project with `Harvest: Review destination`; choose the Harvest project and task before submitting. The command first renders date, local project, duration, and Harvest destination on separate lines in a single column, bounded to 22 physical lines. In interactive OMP sessions, a keyed `Generating work summary…` widget appears while the active model works and is replaced in place by the final summary or unavailable fallback. Summary evidence is ranked by cumulative workstream duration so structured repository and GitHub issue/PR context outweighs fragmented individual prompts. The final generated section contains one to three broad outcome bullets and a suggested Harvest note, remains bounded before display, and keeps the combined result within 30 logical lines. GitHub issue/PR numbers and Jira ticket IDs are extracted as facts, not inferred by the model. `harvest_preview_project_time_drafts` retains source IDs, source kinds, repository identities, intervals, work-item attribution, and narratives for detailed review. Nothing is submitted automatically.
+
+#### Interactive Timesheet Specification
+
+User stories:
+
+- As a worker preparing a Harvest entry, I see one vertical column containing the date, exact local project, total duration, Harvest project/task or review warning, a short work summary, and a suggested note.
+- As a worker waiting for the summary, I see one generation widget replaced in place by the final output.
+- As a worker using `--project`, I see only that exact local project; unrelated projects and excluded records stay hidden.
+- As a reviewer, I see broad duration-weighted work outcomes, generated prose marked for review, and only ticket identifiers grounded in selected evidence.
+- As an auditor, I use the explicit preview tools when I need source IDs, intervals, repository metadata, raw narratives, or attribution details.
+
+The observable contract is a deterministic block of at most 22 physical lines followed by a generated section of at most six lines, keeping the complete result within 30 logical lines. Every total stacks date, exact local project, aggregate duration, and configured Harvest project/task or `Review destination` on separate lines. The generated section uses the `AI-generated work summary (review before use)` heading, one to three concise outcome bullets derived from at most eight duration-ranked evidence records, and a clearly review-marked suggested Harvest note. Generated lines are capped at 100 characters with an ellipsis so one verbose model line cannot consume the screen. In interactive mode, one keyed OMP widget is updated from the generation state to final content; print and RPC modes retain a normal transcript message. The command remains review-only and never writes Harvest.
+
+Type `/omp-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 `omp-worklog` executable.
+- `projectTimeLogPath`: optional path to Project Time v1 evidence; defaults to `~/.omp/project-time/time-log.sqlite`. A legacy versioned JSON snapshot is also supported.
+
+
+## OMP Project Time integration
+
+Configure `projectTimeMappings` with the recorded OMP Project Time project name as the key:
+
+```json
+{
+  "Harvest API": { "project": "Internal", "task": "Development" }
+}
+```
+
+OMP Worklog reads Project Time's persisted `omp-project-time/evidence` v1 entries. An absent, unsupported, or malformed ledger produces a no-write diagnostic; run a current Project Time session to create the SQLite ledger before retrying.
+
+`omp_worklog_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
+
+`omp_worklog_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 and draft entries; it never writes Harvest.
+
+
+
+## Migration from Harvest Worklog
+
+Version `0.14.0` is a clean identity cutover. Uninstall the retired `harvest-worklog` gem and OMP plugin, then install `omp-worklog`; replace former `harvest-worklog` CLI and `/harvest-worklog` command invocations with `omp-worklog` and `/omp-worklog`. The retired package, executable, command, tools, module, and settings aliases are not retained.
+
+## Release
+
+Before merging a release PR, self-review its complete diff, address every actionable review comment, and rerun focused QA after fixups. Record the review and QA evidence on the PR. Then merge to `main`, build and publish the Ruby gem, install the released OMP plugin from GitHub, and verify it:
+
+```bash
+ruby test_omp_worklog.rb
+npm run test:omp
+omp-worklog time-off 2026-08-17 2026-08-28 \
+  --project 'Time Off - Marlen' \
+  --task 'Vacation / PTO' \
+  --holiday-region ca_yt \
+  --dry-run
+VERSION="$(ruby -Ilib -romp_worklog/version -e 'puts OmpWorklog::VERSION')"
+gem build omp-worklog.gemspec
+gem push "omp-worklog-${VERSION}.gem"
+gem uninstall harvest-worklog --all --executables --ignore-dependencies
+gem install --clear-sources --source https://rubygems.org omp-worklog --version "$VERSION" --no-document
+omp plugin uninstall harvest-worklog
+npm run release
+npm run verify:release
+omp-worklog --help
+```
+
+`npm run release` owns the uninstall/force-install mutation. `npm run verify:release` never changes the installation: it checks the installed package version, resolved Git revision, and plugin path before running a deterministic slash-command smoke test against the installed plugin. It exits after verification. Existing OMP sessions retain startup-loaded extension code; restart them before optional manual autocomplete and slash-command QA.

data/bin/omp-worklog

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "omp_worklog"
+
+exit OmpWorklog::CLI.run(ARGV)

data/bin/release-plugin

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+omp plugin uninstall omp-worklog
+omp plugin install --force github:klondikemarlen/omp-worklog

data/bin/verify-plugin-release

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$root"
+version="$(node -p 'require("./package.json").version')"
+expected_revision="$(git rev-parse HEAD)"
+plugin_root="$HOME/.omp/plugins"
+installed_path="$plugin_root/node_modules/omp-worklog/package.json"
+installed_version="$(node -p 'require(process.env.HOME + "/.omp/plugins/node_modules/omp-worklog/package.json").version')"
+resolved_revision="$(node -e '
+const lock = require("node:fs").readFileSync(process.argv[1], "utf8")
+const match = /"omp-worklog"\s*:\s*\[\s*"omp-worklog@github:klondikemarlen\/omp-worklog#([0-9a-f]+)/.exec(lock)
+if (!match) process.exit(1)
+process.stdout.write(match[1])
+' "$plugin_root/bun.lock")" || {
+  printf 'Could not resolve the installed omp-worklog Git revision from %s.\n' "$plugin_root/bun.lock" >&2
+  exit 1
+}
+if [[ "$installed_version" != "$version" || "${expected_revision:0:${#resolved_revision}}" != "$resolved_revision" ]]; then
+  printf 'Expected installed omp-worklog@%s from Git revision %s; found omp-worklog@%s at %s resolved from Git revision %s.\n' "$version" "$expected_revision" "$installed_version" "$installed_path" "$resolved_revision" >&2
+  exit 1
+fi
+node --test "$plugin_root/node_modules/omp-worklog/test/"*.test.js
+printf 'Verified omp-worklog@%s from Git revision %s at %s.\n' "$version" "$resolved_revision" "$installed_path"

data/lib/omp_worklog/version.rb

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

data/lib/omp_worklog/work_entry_cli.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OmpWorklog
+  class WorkEntryCLI
+    EXISTING_ENTRY = 2
+    LOCKED_ENTRY = 3
+
+    def self.run(arguments, output: $stdout, error: $stderr, client: nil)
+      options = { dry_run: false, activity_entry: false }
+      parser = option_parser(options)
+      dates = parser.parse(arguments)
+      validate!(dates, options)
+
+      spent_date = Date.iso8601(dates.first)
+      client ||= Marlens::HarvestApiV2::Client.from_environment
+      project_id, task_id = if options[:project_id]
+                              [options[:project_id], options[:task_id]]
+                            else
+                              TimeOffCLI.resolve_assignment(client, options[:project], options[:task])
+                            end
+      existing_entries = client.request(
+        :get,
+        "/v2/time_entries",
+        params: { project_id:, task_id:, from: spent_date.iso8601, to: spent_date.iso8601 }
+      ).fetch("time_entries")
+
+      if existing_entries.any? { |entry| entry["is_locked"] }
+        output.puts "Locked existing Harvest entry on #{spent_date.iso8601}; skipped"
+        return LOCKED_ENTRY
+      end
+
+      if options[:activity_entry]
+        activity_key = options[:notes].lines.first
+        unrelated_entries = existing_entries.reject { |entry| entry["notes"]&.lines&.first&.start_with?("OMP Project Time activity: ") }
+        if unrelated_entries.any? || existing_entries.any? { |entry| entry["notes"]&.lines&.first == activity_key }
+          output.puts "Existing Harvest entry on #{spent_date.iso8601}; skipped"
+          return EXISTING_ENTRY
+        end
+      elsif existing_entries.any?
+        output.puts "Existing Harvest entry on #{spent_date.iso8601}; skipped"
+        return EXISTING_ENTRY
+      end
+
+      if options[:dry_run]
+        project = options[:project] || "project ##{options[:project_id]}"
+        task = options[:task] || "task ##{options[:task_id]}"
+        output.puts "Would create #{spent_date.iso8601}: #{OmpWorklog.display_hours(options[:hours])}h on #{project} / #{task}; #{options[:notes]}"
+        return 0
+      end
+
+      entry = client.create_time_entry(
+        project_id:,
+        task_id:,
+        spent_date:,
+        hours: options[:hours],
+        notes: options[:notes]
+      )
+      output.puts "Created #{spent_date.iso8601}: #{OmpWorklog.display_hours(options[:hours])}h (entry ##{entry.fetch("id")})"
+      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
+          Usage: omp-worklog work-entry DATE --project NAME --task NAME --hours HOURS --notes NOTES [options]
+                 omp-worklog work-entry DATE --project-id ID --task-id ID --hours HOURS --notes NOTES [options]
+        USAGE
+        opts.on("--project NAME", "Harvest project name") { |value| options[:project] = value }
+        opts.on("--task NAME", "Harvest task name") { |value| options[:task] = value }
+        opts.on("--project-id ID", Integer, "Harvest project ID") { |value| options[:project_id] = value }
+        opts.on("--task-id ID", Integer, "Harvest task ID") { |value| options[:task_id] = value }
+        opts.on("--hours HOURS", Float, "Hours for this entry") { |value| options[:hours] = value }
+        opts.on("--notes NOTES", "Entry description") { |value| options[:notes] = value }
+        opts.on("--dry-run", "Check for existing entries without writing") { options[:dry_run] = true }
+        opts.on("--activity-entry", "Allow distinct OMP Project Time activity entries on the same date, project, and task") { options[:activity_entry] = true }
+        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
+      raise Error, "--hours must be a positive finite number" unless options[:hours]&.positive? && options[:hours].finite?
+      raise Error, "--notes is required" unless options[:notes] && !options[:notes].strip.empty?
+
+      names_provided = options[:project] || options[:task]
+      ids_provided = options[:project_id] || options[:task_id]
+      valid_names = options[:project] && !options[:project].strip.empty? && options[:task] && !options[:task].strip.empty?
+      valid_ids = options[:project_id]&.positive? && options[:task_id]&.positive?
+      raise Error, "supply --project and --task, or --project-id and --task-id" unless valid_names || valid_ids
+      raise Error, "do not combine project/task names with IDs" if names_provided && ids_provided
+    end
+  end
+end

data/lib/omp_worklog.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "omp_worklog/version"
+require "business_time"
+require "date"
+require "json"
+require "holidays"
+require "optparse"
+require "marlens/harvest_api_v2"
+
+module OmpWorklog
+  module_function
+
+  def dates_between(from, to, holiday_regions:)
+    raise Error, "end date must not be before start date" if to < from
+    raise Error, "at least one holiday region is required" if holiday_regions.empty?
+
+    holidays = Holidays.between(from, to, *(holiday_regions.map { |region| region.downcase.to_sym } + [:observed])).map { |holiday| holiday[:date] }
+    (from..to).select { |date| date.workday?(holidays:) }
+  rescue Holidays::InvalidRegion
+    raise Error, "invalid holiday region: #{holiday_regions.join(", ")}"
+  end
+
+  def display_hours(hours)
+    format("%g", hours)
+  end
+
+  class Error < StandardError; end
+
+  class CLI
+    def self.run(arguments, output: $stdout, error: $stderr, client: nil)
+      command, *command_arguments = arguments
+      case command
+      when "time-off"
+        TimeOffCLI.run(command_arguments, output:, error:, client:)
+      when "work-entry"
+        WorkEntryCLI.run(command_arguments, output:, error:, client:)
+      when "-h", "--help"
+        output.puts usage
+        0
+      else
+        error.puts "Error: choose time-off or work-entry"
+        error.puts usage
+        1
+      end
+    end
+
+    def self.usage
+      <<~USAGE
+        Usage:
+          omp-worklog time-off FROM TO --project NAME --task NAME [options]
+          omp-worklog time-off FROM TO --project-id ID --task-id ID [options]
+          omp-worklog work-entry DATE --project NAME --task NAME --hours HOURS --notes NOTES [options]
+          omp-worklog work-entry DATE --project-id ID --task-id ID --hours HOURS --notes NOTES [options]
+
+        Commands:
+          time-off    Create one entry per local business day in a date range.
+          work-entry  Create one reviewed ordinary-work entry.
+      USAGE
+    end
+  end
+
+  class TimeOffCLI
+    def self.run(arguments, output: $stdout, error: $stderr, client: nil)
+      options = { hours: 7.0, dry_run: false, holiday_regions: holiday_regions_from_environment }
+      parser = option_parser(options)
+      dates = parser.parse(arguments)
+      normalize_holiday_regions!(options[:holiday_regions])
+      validate!(dates, options)
+
+      from = Date.iso8601(dates[0])
+      to = Date.iso8601(dates[1])
+      workdays = OmpWorklog.dates_between(from, to, holiday_regions: options[:holiday_regions])
+      raise Error, "date range contains no days to enter" if workdays.empty?
+
+      if options[:dry_run]
+        print_dry_run(output, workdays, options)
+        return 0
+      end
+
+      client ||= Marlens::HarvestApiV2::Client.from_environment
+      project_id, task_id = if options[:project_id]
+                              [options[:project_id], options[:task_id]]
+                            else
+                              resolve_assignment(client, options[:project], options[:task])
+                            end
+
+      workdays.each do |date|
+        entry = client.create_time_entry(
+          project_id:,
+          task_id:,
+          spent_date: date,
+          hours: options[:hours],
+          notes: options[:notes]
+        )
+        output.puts "Created #{date.iso8601}: #{OmpWorklog.display_hours(options[:hours])}h (entry ##{entry.fetch("id")})"
+      end
+      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
+          Usage: omp-worklog time-off FROM TO --project NAME --task NAME [options]
+                 omp-worklog time-off FROM TO --project-id ID --task-id ID [options]
+
+          Creates one Harvest duration entry for each local business day from FROM through TO.
+        USAGE
+        opts.on("--project NAME", "Harvest project name") { |value| options[:project] = value }
+        opts.on("--task NAME", "Harvest task name") { |value| options[:task] = value }
+        opts.on("--project-id ID", Integer, "Harvest project ID") { |value| options[:project_id] = value }
+        opts.on("--task-id ID", Integer, "Harvest task ID") { |value| options[:task_id] = value }
+        opts.on("--hours HOURS", Float, "Hours per day (default: 7)") { |value| options[:hours] = value }
+        opts.on("--notes NOTES", "Optional note on every entry") { |value| options[:notes] = value }
+        opts.on("--holiday-region REGION", "Holidays region; repeat for each locality") { |value| options[:holiday_regions] << value.strip.downcase }
+        opts.on("--dry-run", "Print entries without calling Harvest") { options[:dry_run] = true }
+        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, "--hours must be a positive finite number" unless options[:hours].positive? && options[:hours].finite?
+      raise Error, "--holiday-region or HARVEST_HOLIDAY_REGIONS is required" if options[:holiday_regions].empty?
+      raise Error, "--notes must not be blank" if options[:notes]&.strip&.empty?
+
+      names_provided = options[:project] || options[:task]
+      ids_provided = options[:project_id] || options[:task_id]
+      valid_names = options[:project] && !options[:project].strip.empty? && options[:task] && !options[:task].strip.empty?
+      valid_ids = options[:project_id]&.positive? && options[:task_id]&.positive?
+      raise Error, "supply --project and --task, or --project-id and --task-id" unless valid_names || valid_ids
+      raise Error, "do not combine project/task names with IDs" if names_provided && ids_provided
+    end
+
+    def self.holiday_regions_from_environment
+      ENV.fetch("HARVEST_HOLIDAY_REGIONS", "ca_yt").split(",").map { |region| region.strip.downcase }.reject(&:empty?)
+    end
+
+    def self.normalize_holiday_regions!(regions)
+      regions.map! { |region| region.strip.downcase }
+      regions.reject!(&:empty?)
+      regions.uniq!
+      regions
+    end
+
+    def self.resolve_assignment(client, project_name, task_name)
+      # ponytail: one 2,000-item page covers personal assignments; follow cursor pagination if that ceiling is exceeded.
+      matches = client.active_personal_task_assignments.select do |assignment|
+        assignment.dig("project", "name")&.casecmp?(project_name) &&
+          assignment.dig("task", "name")&.casecmp?(task_name)
+      end
+
+      return [matches.first.dig("project", "id"), matches.first.dig("task", "id")] if matches.one?
+
+      qualifier = "project #{project_name.inspect} and task #{task_name.inspect}"
+      raise Error, "No active task assignment matches #{qualifier}. Pass --project-id and --task-id instead." if matches.empty?
+
+      raise Error, "Multiple active task assignments match #{qualifier}. Pass --project-id and --task-id instead."
+    end
+
+    def self.print_dry_run(output, dates, options)
+      project = options[:project] || "project ##{options[:project_id]}"
+      task = options[:task] || "task ##{options[:task_id]}"
+      notes = options[:notes] ? "; #{options[:notes]}" : ""
+      dates.each do |date|
+        output.puts "Would create #{date.iso8601}: #{OmpWorklog.display_hours(options[:hours])}h on #{project} / #{task}#{notes}"
+      end
+    end
+  end
+end
+
+require "omp_worklog/work_entry_cli"

data/omp-worklog.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "omp_worklog"
+
+exit OmpWorklog::CLI.run(ARGV)

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: omp-worklog
+version: !ruby/object:Gem::Version
+  version: 0.14.0
+platform: ruby
+authors:
+- Marlen Brunner
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: marlens-harvest-api-v2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: business_time
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: holidays
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.2'
+description:
+email:
+- klondikemarlen@gmail.com
+executables:
+- omp-worklog
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/omp-worklog
+- bin/release-plugin
+- bin/verify-plugin-release
+- lib/omp_worklog.rb
+- lib/omp_worklog/version.rb
+- lib/omp_worklog/work_entry_cli.rb
+- omp-worklog.rb
+homepage: https://github.com/klondikemarlen/omp-worklog
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/klondikemarlen/omp-worklog
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: OMP Project Time work logs with an optional manual Harvest destination.
+test_files: []