fewald-worklog 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95211b380e35341b87a230655872177aa6bcb4263fcdbc0b0a590bdc357346d3
+  data.tar.gz: d64857404d738154ee5b5b7bd717eea2d862bad294cede2946b1debf08f6940d
+SHA512:
+  metadata.gz: 27f40f229dc637b3985793a8b2bcb5858ac3883cc739a5bc56c77919e65d3a6580b7deac2e1f5825e9165da0035754f3b15d68a22e4971bf460b0c51be4048bc
+  data.tar.gz: 4292212bb151fe886c8996b8538144b7a76427e5518783d62bc40616a3c969fe398edbfbaa2fcfbc042c76785f11fba1ad186670a378bcccbe2f45264e3e7e23

data/bin/wl

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This is the main entry point for the worklog CLI.
+
+if ENV['WL_PATH']
+  # Import the worklog CLI from the path specified in the WL_PATH environment variable
+  # This is used during development to avoid having to rely on the order of the $PATH.
+  require_relative File.join(ENV['WL_PATH'], 'worklog', 'cli')
+else
+  require_relative '../worklog/cli'
+end
+
+WorklogCLI.start

data/worklog/cli.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the current directory to the load path
+curr_dir = File.expand_path(__dir__)
+$LOAD_PATH << curr_dir unless $LOAD_PATH.include?(curr_dir)
+
+require 'thor'
+require 'date'
+require 'logger'
+
+require 'date_parser'
+require 'printer'
+require 'statistics'
+require 'storage'
+require 'webserver'
+require 'worklog'
+require_relative 'summary'
+require_relative 'editor'
+require_relative 'string_helper'
+
+# CLI for the work log application
+class WorklogCLI < Thor
+  include StringHelper
+  class_option :verbose, type: :boolean, aliases: '-v', desc: 'Enable verbose output'
+
+  package_name 'Worklog'
+
+  def self.exit_on_failure?
+    true
+  end
+
+  desc 'add MESSAGE', 'Add a new entry to the work log, defaults to the current date.'
+  long_desc <<~LONGDESC
+    Add a new entry with the current date and time to the work log.
+    The message is required and must be enclosed in quotes if it contains more than one word.
+
+    People can be referenced either by using the tilde "~" or the at symbol "@", followed by
+    an alphanumeric string.
+  LONGDESC
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d'), desc: 'Set the date of the entry'
+  option :time, type: :string, default: DateTime.now.strftime('%H:%M:%S'), desc: 'Set the time of the entry'
+  option :tags, type: :array, default: [], desc: 'Add tags to the entry'
+  option :ticket, type: :string, desc: 'Ticket number associated with the entry. Can be any alphanumeric string.'
+  option :url, type: :string, desc: 'URL to associate with the entry'
+  option :epic, type: :boolean, default: false, desc: 'Mark the entry as an epic'
+  def add(message)
+    set_log_level
+
+    # Remove leading and trailing whitespaces
+    # Raise an error if the message is empty
+    message = message.strip
+    raise ArgumentError, 'Message cannot be empty' if message.empty?
+
+    date = Date.strptime(options[:date], '%Y-%m-%d')
+    time = Time.strptime(options[:time], '%H:%M:%S')
+    Storage.create_file_skeleton(date)
+
+    daily_log = Storage.load_log(Storage.filepath(date))
+    daily_log.entries << LogEntry.new(time:, tags: options[:tags], ticket: options[:ticket], url: options[:url],
+                                      epic: options[:epic], message:)
+
+    # Sort by time in case an entry was added later out of order.
+    daily_log.entries.sort_by!(&:time)
+
+    Storage.write_log(Storage.filepath(options[:date]), daily_log)
+    WorkLogger.info Rainbow("Added to the work log for #{options[:date]}").green
+  end
+
+  desc 'edit', 'Edit a specified day in the work log'
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
+  def edit
+    set_log_level
+
+    date = Date.strptime(options[:date], '%Y-%m-%d')
+
+    # Load existing log
+    log = Storage.load_log(Storage.filepath(date))
+    unless log
+      WorkLogger.error "No work log found for #{options[:date]}. Aborting."
+      exit 1
+    end
+
+    txt = Editor::EDITOR_PREAMBLE.result_with_hash(content: YAML.dump(log))
+    return_val = Editor.open_editor(txt)
+
+    Storage.write_log(Storage.filepath(date),
+                      YAML.load(return_val, permitted_classes: [Date, Time, DailyLog, LogEntry]))
+    WorkLogger.info Rainbow("Updated work log for #{options[:date]}").green
+  end
+
+  desc 'remove', 'Remove last entry from the log'
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
+  def remove
+    set_log_level
+
+    date = Date.strptime(options[:date], '%Y-%m-%d')
+    unless File.exist?(Storage.filepath(date))
+      WorkLogger.error Rainbow("No work log found for #{options[:date]}. Aborting.").red
+      exit 1
+    end
+
+    daily_log = Storage.load_log(Storage.filepath(options[:date]))
+    if daily_log.entries.empty?
+      WorkLogger.error Rainbow("No entries found for #{options[:date]}. Aborting.").red
+      exit 1
+    end
+
+    removed_entry = daily_log.entries.pop
+    Storage.write_log(Storage.filepath(date), daily_log)
+    WorkLogger.info Rainbow("Removed entry: #{removed_entry.message}").green
+  end
+
+  desc 'show', 'Show the work log for a specific date or a range of dates. Defaults to todays date.'
+  long_desc <<~LONGDESC
+    Show the work log for a specific date or a range of dates. As a default, all items from the current day will be shown.
+  LONGDESC
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d'),
+                desc: <<~DESC
+                  Show the work log for a specific date. If this option is provided, --from and --to and --days should not be used.
+                DESC
+  option :from, type: :string, desc: <<~EOF
+    Inclusive start date of the range. Takes precedence over --date, if defined.
+  EOF
+  option :to, type: :string, desc: <<~EOF
+    Inclusive end date of the range. Takes precedence over --date, if defined.
+  EOF
+  option :days, type: :numeric, desc: <<~EOF
+    Number of days to show starting from --date. Takes precedence over --from and --to if defined.
+  EOF
+  option :epics_only, type: :boolean, default: false, desc: 'Show only entries that are marked as epic'
+  option :tags, type: :array, default: [], desc: 'Filter entries by tags. Tags are treated as an OR condition.'
+  def show
+    set_log_level
+
+    start_date, end_date = start_end_date(options)
+
+    entries = Storage.days_between(start_date, end_date)
+    if entries.empty?
+      Printer.no_entries(start_date, end_date)
+    else
+      entries.each do |entry|
+        Printer.print_day(entry, entries.size > 1, options[:epics_only])
+      end
+    end
+  end
+
+  desc 'people', 'Show all people mentioned in the work log'
+  def people
+    set_log_level
+
+    puts 'People mentioned in the work log:'
+
+    mentions = {}
+    all_logs = Storage.all_days
+    all_logs.map(&:people).each do |people|
+      mentions.merge!(people) { |_key, oldval, newval| oldval + newval }
+    end
+    mentions.each { |k, v| puts "#{Rainbow(k).gold}: #{v} #{pluralize(v, 'occurrence')}" }
+  end
+
+  desc 'tags', 'Show all tags used in the work log'
+  def tags
+    set_log_level
+
+    all_logs = Storage.all_days
+
+    puts Rainbow('Tags used in the work log:').gold
+
+    # Count all tags used in the work log
+    tags = all_logs.map(&:entries).flatten.map(&:tags).flatten.compact.tally
+
+    # Determine length of longest tag for formatting
+    max_len = tags.keys.map(&:length).max
+
+    tags.each { |k, v| puts "#{Rainbow(k.ljust(max_len)).gold}: #{v} #{pluralize(v, 'occurrence')}" }
+  end
+
+  desc 'server', 'Start the work log server'
+  def server
+    set_log_level
+
+    WorkLogServer.new.start
+  end
+
+  desc 'stats', 'Show statistics for the work log'
+  def stats
+    stats = Statistics.calculate
+    puts "#{format_left('Total days')}: #{stats.total_days}"
+    puts "#{format_left('Total entries')}: #{stats.total_entries}"
+    puts "#{format_left('Total epics')}: #{stats.total_epics}"
+    puts "#{format_left('Entries per day')}: #{'%.2f' % stats.avg_entries}"
+    puts "#{format_left('First entry')}: #{stats.first_entry}"
+    puts "#{format_left('Last entry')}: #{stats.last_entry}"
+  end
+
+  desc 'summary', 'Generate a summary of the work log entries'
+  option :date, type: :string, default: DateTime.now.strftime('%Y-%m-%d')
+  option :from, type: :string, desc: <<-EOF
+    'Inclusive start date of the range. Takes precedence over --date if defined.'
+  EOF
+  option :to, type: :string, desc: <<-EOF
+    'Inclusive end date of the range. Takes precedence over --date if defined.'
+  EOF
+  option :days, type: :numeric, desc: <<-EOF
+    'Number of days to show starting from --date. Takes precedence over --from and --to if defined.'
+  EOF
+  def summary
+    set_log_level
+
+    start_date, end_date = start_end_date(options)
+    entries = Storage.days_between(start_date, end_date).map(&:entries).flatten
+
+    # Do nothing if no entries are found.
+    if entries.empty?
+      Printer.no_entries(start_date, end_date)
+      return
+    end
+    puts Summary.generate_summary(entries)
+  end
+
+  # Define shortcuts and aliases
+  map 'a' => :add
+  map 'statistics' => :stats
+  map 'serve' => :server
+
+  no_commands do
+    def set_log_level
+      # Set the log level based on the verbose option
+      WorkLogger.level = options[:verbose] ? Logger::Severity::DEBUG : Logger::Severity::INFO
+    end
+
+    def format_left(string)
+      # Format a string to be left-aligned in a fixed-width field
+      #
+      # @param string [String] the string to format
+      # @return [String] the formatted string
+      format('%18s', string)
+    end
+
+    # Parse the start and end date based on the options provided
+    #
+    # @param options [Hash] the options hash
+    # @return [Array] the start and end date as an array
+    def start_end_date(options)
+      if options[:days]
+        # Safeguard against negative days
+        raise ArgumentError, 'Number of days cannot be negative' if options[:days].negative?
+
+        start_date = Date.today - options[:days]
+        end_date = Date.today
+      elsif options[:from]
+        start_date = DateParser.parse_date_string!(options[:from], true)
+        end_date = DateParser.parse_date_string!(options[:to], false) if options[:to]
+      else
+        start_date = Date.strptime(options[:date], '%Y-%m-%d')
+        end_date = start_date
+      end
+      [start_date, end_date]
+    end
+  end
+end
+
+# Start the CLI if the file is executed
+# This prevents the CLI from starting when the file is required in another file,
+# which is useful for testing.
+WorklogCLI.start if __FILE__ == $PROGRAM_NAME

data/worklog/daily_log.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'hash'
+
+class DailyLog
+  # Container for a day's work log.
+  include Hashify
+
+  # Represents a single day's work log.
+  attr_accessor :date, :entries
+
+  def initialize(params = {})
+    @date = params[:date]
+    @entries = params[:entries]
+  end
+
+  def people?
+    # Returns true if there are people mentioned in any entry of the current day.
+    people.size.positive?
+  end
+
+  def people
+    # Returns a hash of people mentioned in the log for the current day
+    # with the number of times they are mentioned.
+    # People are defined as words starting with @ or ~.
+    #
+    # @return [Hash<String, Integer>]
+    entries.map(&:people).flatten.tally
+  end
+
+  def ==(other)
+    date == other.date && entries == other.entries
+  end
+end

data/worklog/date_parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module DateParser
+  # Best effort date parsing from multiple formats.
+  def self.parse_date_string(date_str, from_beginning = true)
+    return nil if date_str.nil?
+    return nil if date_str.empty?
+    return nil if date_str.length > 10
+
+    # Try to parse basic format YYYY-MM-DD
+    begin
+      return Date.strptime(date_str, '%Y-%m-%d') if date_str.match(/^\d{4}-\d{1,2}-\d{1,2}$/)
+    rescue Date::Error
+      # puts "Date not in format YYYY-MM-DD."
+    end
+
+    # Try to parse format YYYY-MM
+    begin
+      if date_str.match(/^\d{4}-\d{1,2}$/)
+        d = Date.strptime(date_str, '%Y-%m')
+        return d if from_beginning
+
+        return Date.new(d.year, d.month, -1)
+
+      end
+    rescue Date::Error
+      # puts "Date not in format YYYY-MM."
+    end
+
+    # Try to parse format YYYY (without Q1234)
+    if date_str.match(/^\d{4}$/)
+      d = Date.strptime(date_str, '%Y')
+      return d if from_beginning
+
+      return Date.new(d.year, -1, -1)
+
+    end
+
+    # Long form quarter (2024-Q1, etc.)
+    match = date_str.match(/(\d{4})-[qQ]([1234])/)
+    if match
+      year, quarter = match.captures.map(&:to_i)
+      d = Date.new(year, ((quarter - 1) * 3) + 1, 1)
+      return d if from_beginning
+
+      return Date.new(d.year, d.month + 2, -1)
+
+    end
+
+    # Short form quarter
+    match = date_str.match(/[qQ]([1234])/)
+    return unless match
+
+    quarter = match.captures.first.to_i
+    d = Date.new(Date.today.year, ((quarter - 1) * 3) + 1, 1)
+    return d if from_beginning
+
+    Date.new(d.year, d.month + 2, -1)
+  end
+
+  def self.parse_date_string!(date_str, from_beginning = true)
+    date = parse_date_string(date_str, from_beginning)
+    raise ArgumentError, "Could not parse date string: \"#{date_str}\"" if date.nil?
+
+    date
+  end
+end

data/worklog/editor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'tempfile'
+
+# Editor to handle editing of log entries.
+module Editor
+  EDITOR_PREAMBLE = ERB.new <<~README
+    # Edit the content below, then save the file and quit the editor.
+    # The update content will be saved. The content MUST be valid YAML
+    # in order for the application to be able to update the records.
+
+    <%= content %>
+  README
+
+  # Open text editor (currently ViM) with the initial text.
+  # Upon saving and exiting the editor, the updated text is returned.
+  # @param initial_text [String] The initial text to display in the editor.
+  # @return [String] The updated text.
+  def self.open_editor(initial_text)
+    file_handle = Tempfile.create
+    file_handle.write(initial_text)
+    file_handle.close
+
+    # Open the editor with the temporary file.
+    system('vim', file_handle.path)
+
+    updated_text = nil
+
+    # Read the updated text from the file.
+    File.open(file_handle.path, 'r') do |f|
+      updated_text = f.read
+      WorkLogger.debug("Updated text: #{updated_text}")
+    end
+    File.unlink(file_handle.path)
+    updated_text
+  end
+end

data/worklog/hash.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hashify
+  def to_hash
+    hash = {}
+    instance_variables.each do |var|
+      value = instance_variable_get(var)
+      hash[var.to_s.delete('@')] = value
+    end
+    hash
+  end
+end
+
+class Hash
+  # Convert all keys to strings so that the YAML file can be read from different languages.
+  # This is a monkey patch to the Hash class.
+
+  def stringify_keys
+    # Convert all keys to strings.
+    # This is useful when the hash is serialized to YAML.
+    #
+    # @return [Hash] the hash with all keys converted to strings
+    map { |k, v| [k.to_s, v] }.to_h
+  end
+end

data/worklog/log_entry.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'rainbow'
+require_relative 'daily_log'
+require_relative 'hash'
+
+# A single log entry.
+class LogEntry
+  include Hashify
+
+  # Represents a single entry in the work log.
+  attr_accessor :time, :tags, :ticket, :url, :epic, :message
+
+  def initialize(params = {})
+    @time = params[:time]
+    # If tags are nil, set to empty array.
+    # This is similar to the CLI default value.
+    @tags = params[:tags] || []
+    @ticket = params[:ticket]
+    @url = params[:url] || ''
+    @epic = params[:epic]
+    @message = params[:message]
+  end
+
+  # Returns true if the entry is an epic, false otherwise.
+  def epic?
+    @epic == true
+  end
+
+  # Returns the message string with formatting without the time.
+  def message_string
+    s = ''
+
+    s += if epic
+           Rainbow("[EPIC] #{@message}").bg(:white).fg(:black)
+         else
+           message
+         end
+
+    s += "  [#{Rainbow(@ticket).fg(:blue)}]" if @ticket
+
+    # Add tags in brackets if defined.
+    s += '  [' + @tags.map { |tag| "#{tag}" }.join(', ') + ']' if @tags && @tags.size > 0
+
+    # Add URL in brackets if defined.
+    s += "  [#{@url}]" if @url && @url != ''
+
+    s
+  end
+
+  def people
+    # Return people that are mentioned in the entry.
+    # People are defined as words starting with @ or ~.
+    # Whitespaces are used to separate people.
+    # Punctuation is not considered.
+    # Empty array if no people are mentioned.
+    #
+    # @return [Array<String>]
+    @message.scan(/\s[~@](\w+)/).flatten.uniq.sort
+  end
+
+  def people?
+    # Return true if there are people in the entry.
+    #
+    # @return [Boolean]
+    people.size.positive?
+  end
+
+  def to_yaml
+    to_hash.to_yaml
+  end
+
+  def ==(other)
+    time == other.time && tags == other.tags && ticket == other.ticket && url == other.url &&
+      epic == other.epic && message == other.message
+  end
+end

data/worklog/logger.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'singleton'
+
+# Singleton class for logging work log messages
+class WorkLogger
+  include Singleton
+
+  def self.instance
+    @instance ||= Logger.new($stdout)
+  end
+
+  def self.level=(level)
+    instance.level = level
+  end
+
+  def self.level
+    instance.level
+  end
+
+  def self.info(message) = instance.info(message)
+  def self.warn(message) = instance.warn(message)
+  def self.error(message) = instance.error(message)
+  def self.debug(message) = instance.debug(message)
+end

data/worklog/person.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# typed: true
+
+# Represents a person at work.
+class Person
+  attr_reader :handle, :name, :email, :team, :notes
+
+  def initialize(handle, name, email, team, notes = [])
+    @handle = handle
+    @name = name
+    @email = email
+    @team = team
+    @notes = notes
+  end
+
+  def to_s
+    "#{name} (~#{handle}) <#{email}>"
+  end
+end

data/worklog/printer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+# Printer for work log entries
+module Printer
+  # Prints a whole day of work log entries.
+  # If date_inline is true, the date is printed inline with the time.
+  # If epics_only is true, only epic entries are printed.
+  def self.print_day(daily_log, date_inline = false, epics_only = false)
+    daily_log.date = Date.strptime(daily_log.date, '%Y-%m-%d') unless daily_log.date.respond_to?(:strftime)
+
+    date_string = daily_log.date.strftime('%a, %B %-d, %Y')
+    puts "Work log for #{Rainbow(date_string).gold}" unless date_inline
+
+    daily_log.entries.each do |entry|
+      next if epics_only && !entry.epic?
+
+      print_entry(daily_log, entry, date_inline)
+    end
+  end
+
+  # Print a message when no entries are found.
+  # @param start_date [Date]
+  # @param end_date [Date]
+  # @return [void]
+  def self.no_entries(start_date, end_date)
+    if start_date == end_date
+      date_string = start_date.strftime('%a, %B %-d, %Y')
+      puts "No entries found for #{Rainbow(date_string).gold}."
+    else
+      start_date_string = start_date.strftime('%a, %B %-d, %Y')
+      end_date_string = end_date.strftime('%a, %B %-d, %Y')
+      puts "No entries found between #{Rainbow(start_date_string).gold} and #{Rainbow(end_date_string).gold}."
+    end
+  end
+
+  private
+
+  # Prints a single entry, formats the date and time.
+  def print_entry(daily_log, entry, date_inline = false)
+    entry.time = DateTime.strptime(entry.time, '%H:%M:%S') unless entry.time.respond_to?(:strftime)
+
+    time_string = if date_inline
+                    "#{daily_log.date.strftime('%a, %Y-%m-%d')} #{entry.time.strftime('%H:%M')}"
+                  else
+                    entry.time.strftime('%H:%M')
+                  end
+
+    puts "#{Rainbow(time_string).gold} #{entry.message_string}"
+  end
+
+  module_function :print_entry
+end

data/worklog/statistics.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'storage'
+
+STATS = Data.define(:total_days, :total_entries, :total_epics, :avg_entries, :first_entry, :last_entry)
+
+# Module for calculating statistics for the work log.
+module Statistics
+  # Calculate statistics for the work log for all days.
+  # @return [STATS]
+  def self.calculate
+    all_entries = Storage.all_days
+    return STATS.new(0, 0, 0, 0, Date.today, Date.today) if all_entries.empty?
+
+    total_days = all_entries.length
+    total_entries = all_entries.sum { |entry| entry.entries.length }
+    total_epics = all_entries.sum { |entry| entry.entries.select { |item| item.epic? }.length }
+    avg_entries = total_entries.to_f / total_days
+    min_day = all_entries.min_by { |entry| entry.date }.date
+    max_day = all_entries.max_by { |entry| entry.date }.date
+
+    STATS.new(
+      total_days,
+      total_entries,
+      total_epics,
+      avg_entries,
+      min_day,
+      max_day
+    )
+  end
+end

data/worklog/storage.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+require_relative 'daily_log'
+require_relative 'logger'
+
+module Storage
+  # LogNotFoundError is raised when a log file is not found
+  class LogNotFoundError < StandardError; end
+
+  FILE_SUFFIX = '.yaml'
+  DATA_DIR = File.join(Dir.home, '.worklog')
+
+  def self.folder_exists?
+    Dir.exist?(DATA_DIR)
+  end
+
+  # Return all days with logs
+  def self.all_days
+    return [] unless folder_exists?
+
+    logs = []
+    Dir.glob(File.join(DATA_DIR, "*#{FILE_SUFFIX}")).map do |file|
+      logs << load_log(file)
+    end
+
+    logs
+  end
+
+  # Return days between start_date and end_date
+  # If end_date is nil, return logs from start_date to today
+  #
+  # @param [Date] start_date The start date, inclusive
+  # @param [Date] end_date The end date, inclusive
+  # @param [Boolean] epics_only If true, only return logs with epic entries
+  # @param [Array] tags_filter If provided, only return logs with entries that have at least one of the tags
+  def self.days_between(start_date, end_date = nil, epics_only = nil, tags_filter = nil)
+    return [] unless folder_exists?
+
+    logs = []
+    end_date = Date.today if end_date.nil?
+
+    return [] if start_date > end_date
+
+    while start_date <= end_date
+      if File.exist?(filepath(start_date))
+        tmp_logs = load_log(filepath(start_date))
+        tmp_logs.entries.keep_if { |entry| entry.epic? } if epics_only
+
+        if tags_filter
+          # Safeguard against entries without any tags, not just empty array
+          tmp_logs.entries.keep_if { |entry| entry.tags && (entry.tags & tags_filter).size > 0 }
+        end
+
+        logs << tmp_logs if tmp_logs.entries.length > 0
+      end
+
+      start_date += 1
+    end
+    logs
+  end
+
+  # Create file for a new day if it does not exist
+  def self.create_file_skeleton(date)
+    create_folder
+
+    File.write(filepath(date), YAML.dump(DailyLog.new(date:, entries: []))) unless File.exist?(filepath(date))
+  end
+
+  def self.load_log(file)
+    load_log!(file)
+  rescue LogNotFoundError
+    WorkLogger.error "No work log found for #{file}. Aborting."
+    nil
+  end
+
+  def self.load_log!(file)
+    WorkLogger.debug "Loading file #{file}"
+    begin
+      log = YAML.load_file(file, permitted_classes: [Date, Time, DailyLog, LogEntry])
+      log.entries.each do |entry|
+        entry.time = Time.parse(entry.time) unless entry.time.respond_to?(:strftime)
+      end
+      log
+    rescue Errno::ENOENT
+      raise LogNotFoundError
+    end
+  end
+
+  def self.write_log(file, daily_log)
+    create_folder
+
+    WorkLogger.debug "Writing to file #{file}"
+
+    File.open(file, 'w') do |f|
+      f.puts daily_log.to_yaml
+    end
+  end
+
+  def self.load_single_log_file(file, headline = true)
+    daily_log = load_log(file)
+    puts "Work log for #{Rainbow(daily_log.date).gold}:" if headline
+    daily_log.entries
+  end
+
+  private
+
+  # Create folder if not exists already.
+  def create_folder
+    Dir.mkdir(DATA_DIR) unless Dir.exist?(DATA_DIR)
+  end
+
+  def filepath(date)
+    # Construct filepath for a given date.
+    File.join(DATA_DIR, "#{date}#{FILE_SUFFIX}")
+  end
+
+  module_function :create_folder, :filepath
+end

data/worklog/string_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# typed: true
+
+# Helpers for String manipulation
+module StringHelper
+  # Pluralize a word based on a count. If the plural form is irregular, it can be provided.
+  # Otherwise, it will be generated automatically.
+  #
+  # @param count [Integer] the count to base the pluralization on
+  # @param singular [String] the singular form of the word
+  # @param plural [String] the plural form of the word, if it is irregular. Otherwise it will be generated.
+  # @return [String] the pluralized word
+  def pluralize(count, singular, plural = nil)
+    if count == 1
+      singular
+    else
+      return plural if plural
+
+      return "#{singular[0..-2]}ies" if singular.end_with? 'y'
+
+      return "#{singular}es" if singular.end_with? 'ch', 's', 'sh', 'x', 'z'
+
+      return "#{singular[0..-2]}ves" if singular.end_with? 'f', 'fe'
+
+      "#{singular}s"
+    end
+  end
+end

data/worklog/summary.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'httparty'
+require 'json'
+
+require_relative 'logger'
+
+# AI Summary generation.
+module Summary
+  MODEL = 'llama3.2'
+  SUMMARY_INSTRUCTION = <<~INSTRUCTION
+    <% entries.each do |entry| -%>
+    <%= entry.message %>
+    <% end -%>
+  INSTRUCTION
+
+  SYSTEM_INSTRUCTION = <<~INSTRUCTION
+    You are a professional summarization assistant specialized in crafting performance review summaries. Your role is to take a list of achievements provided by the user and generate a concise, professional summary suitable for use in a formal performance review.
+
+    Guidelines:
+
+    Accuracy: Do not invent or infer any facts not explicitly provided by the user. Use only the information given.
+    Tone: Maintain a formal, professional tone throughout the summary.
+    Structure: Organize the summary in a coherent manner, emphasizing key accomplishments and their impact.
+    Clarity: Use clear and concise language, avoiding jargon unless specified by the user.
+    Your Task:
+
+    Analyze the list of achievements provided by the user.
+    Identify the key themes and accomplishments.
+    Draft a polished summary that highlights the individual’s contributions and results.
+    Constraints:
+
+    Do not fabricate details or add context that has not been explicitly stated.
+    Always prioritize clarity and professionalism in your writing.
+    Example Input:
+
+    "Exceeded sales targets by 15% in Q3."
+    "Implemented a new CRM system, reducing customer response time by 30%."
+    "Mentored two junior team members, both of whom received promotions."
+    Example Output: "[Name] demonstrated outstanding performance during the review period. Key accomplishments include exceeding sales targets by 15% in Q3, implementing a new CRM system that improved customer response times by 30%, and mentoring two junior team members who achieved career advancements. These achievements highlight [Name]'s exceptional contributions to team success and organizational growth."
+  INSTRUCTION
+
+  # Build the prompt from provided log entries.
+  def self.build_prompt(log_entries)
+    ERB.new(SUMMARY_INSTRUCTION, trim_mode: '-').result_with_hash(entries: log_entries)
+  end
+
+  # Generate a summary from provided log entries.
+  def self.generate_summary(log_entries)
+    prompt = build_prompt(log_entries)
+
+    WorkLogger.debug("Using prompt: #{prompt}")
+
+    begin
+      response = HTTParty.post('http://localhost:11434/api/generate',
+                               body: {
+                                 model: Summary::MODEL,
+                                 prompt:,
+                                 system: Summary::SYSTEM_INSTRUCTION,
+                                 stream: false
+                               }.to_json,
+                               headers: { 'Content-Type' => 'application/json' })
+      response.parsed_response['response']
+    rescue Errno::ECONNREFUSED
+      WorkLogger.error <<~MSG
+        Ollama doesn't seem to be running. Please start the server and try again.
+        puts 'You can download Ollama at https://ollama.com'
+      MSG
+    end
+  end
+end

data/worklog/templates/favicon.svg.erb

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="128" height="128" viewBox="0 0 128 128" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <rect fill="#fff" stroke="#000" x="0" y="0" width="128" height="128" stroke-width="4" />
+    <rect fill="#fff" stroke="#000" x="32" y="32" width="64" height="64" stroke-width="2" />
+    <text x="10" y="30" fill="green" font-size="32"><%= Date.today %></text>
+</svg>

data/worklog/templates/index.html.erb

@@ -0,0 +1,150 @@
+<html>
+    <head>
+        <title>Work log</title>
+        <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+        <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+        <link rel="icon" href="favicon.svg">
+        <link rel="mask-icon" href="favicon.svg" color="#000000">
+        <style type="text/css">
+
+            ul {
+                list-style-type: none;
+                padding: 0 1rem;
+            }
+
+            /* Special style for presentation mode */
+            .presentation {
+                .day {
+                    font-size: 2rem;
+                    line-height: 2.6rem;
+
+                    ul {
+                        border-bottom: 2px solid #AAA;
+                        li {
+                            padding-bottom: 1rem;
+                        }
+                    }
+
+                    .entries {
+                        display: none;
+                    }
+                }
+            }
+        </style>
+    </head>
+    <body>
+    <div class="container <%= presentation ? 'presentation' : '' %>">
+        <nav class="navbar navbar-expand-lg bg-body-tertiary">
+            <div class="container-fluid">
+                <a class="navbar-brand" href="/">
+                    <% if tags %>
+                        <%= tags.first.capitalize %> items
+                    <% else %>
+                        Work log
+                    <% end %>
+                </a>
+                <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+                    <span class="navbar-toggler-icon"></span>
+                </button>
+                <div class="collapse navbar-collapse" id="navbarSupportedContent">
+                    <div class="navbar-nav me-auto"></div>
+                    <div class="d-flex">
+            <% if presentation %>
+                <a href="<%= update_query({'presentation' => nil}) %>" class="btn btn-primary">
+                    Screen
+                </a>
+            <% else %>
+                <a href="<%= update_query({'presentation' => true}) %>" class="btn btn-primary">
+                    Presentation
+                </a>
+            <% end %>
+            </div>
+                </div>
+            </div>
+
+
+        </nav>
+
+        <hr class="border border-primary border-2 opacity-75">
+            <div class="pb-4">
+            Show
+            <div class="dropdown d-inline">
+                <a class="btn border-secondary dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">
+                    <% if epics_only %>
+                    only epics
+                    <% else %>
+                    all items
+                    <% end %>
+                </a>
+                <ul class="dropdown-menu">
+                    <li><a class="dropdown-item" href="<%= update_query({'epics_only' => false}) %>">all items</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'epics_only' => true}) %>">only epics</a></li>
+                </ul>
+            </div>
+             from the last
+            <div class="dropdown d-inline">
+                <a class="btn border-secondary dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">
+                    <%= days %> days
+                </a>
+                <ul class="dropdown-menu">
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 7}) %>">7 days</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 14}) %>">2 weeks</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 21}) %>">3 weeks</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 28}) %>">4 weeks</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 60}) %>">2 months</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 90}) %>">3 months</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 180}) %>">6 months</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'days' => 365}) %>">1 year</a></li>
+                </ul>
+            </div>
+            of work with
+            <div class="dropdown d-inline">
+                <a class="btn border-secondary dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">
+                    <% if tags %>
+                        <%= tags.first %> tag
+                    <% else %>
+                        all tags
+                    <% end %>
+                </a>
+                <ul class="dropdown-menu">
+                    <li><a class="dropdown-item" href="<%= update_query({'tags' => nil}) %>">all tags</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'tags' => ['oncall']}) %>">oncall tags</a></li>
+                    <li><a class="dropdown-item" href="<%= update_query({'tags' => ['1:1']}) %>">1:1 tags</a></li>
+                </ul>
+            </div>
+            .
+            </div>
+
+
+
+        <%- logs.each do |log| -%>
+            <section class="day">
+            <strong><%= log.date.strftime('%a, %B %-d, %Y') %></strong>
+
+            <ul>
+            <%- log.entries.each do |entry| -%>
+                <li>
+                    <code><%= entry.time.strftime('%H:%M') %></code>
+                    <% if entry.epic %>
+                        <span class="badge text-bg-warning">EPIC</span>
+                    <% end%>
+                    <%= entry.message %>
+                    <% if entry.tags and entry.tags.size > 0 %>
+                        <% entry.tags.each do |tag| %>
+                            <strong class="badge text-bg-secondary"><%= tag %></strong>
+                        <% end %>
+                    <% end %>
+                </li>
+            <%- end %>
+            </ul>
+            <p class="entries"><%= log.entries.size %> entries</p>
+            </section>
+        <%- end %>
+        <p><%= total_entries%> entries total</p>
+    </div>
+    <hr/>
+    <footer class="container pb-4">
+        Generated at <%= Time.now.strftime('%Y-%m-%d %H:%M %Z') %>
+    </footer>
+    </body>
+</html>

data/worklog/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+# Returns the current version of the gem from `.version`.
+# Versioning follows SemVer.
+# @return [String] The current version of the gem.
+def current_version
+  version_file_path = File.join(Pathname.new(__dir__).parent, '.version')
+  File.read(version_file_path).strip
+end

data/worklog/webserver.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'erb'
+require 'rack'
+require 'rack/constants'
+require 'rackup'
+require 'uri'
+require_relative 'storage'
+require_relative 'worklog'
+
+class DefaultHeaderMiddleware
+  # Rack middleware to add default headers to the response.
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+    headers[Rack::CONTENT_TYPE] ||= 'text/html'
+    headers[Rack::CACHE_CONTROL] ||= 'no-cache'
+    [status, headers, body]
+  end
+end
+
+class WorkLogResponse
+  # Class to render the main page of the WorkLog web application.
+
+  def response(request)
+    template = ERB.new(File.read(File.join(File.dirname(__FILE__), 'templates', 'index.html.erb')), trim_mode: '-')
+    @params = request.params
+    days = @params['days'].nil? ? 7 : @params['days'].to_i
+    tags = @params['tags'].nil? ? nil : @params['tags'].split(',')
+    epics_only = @params['epics_only'] == 'true'
+    presentation = @params['presentation'] == 'true'
+    logs = Storage.days_between(Date.today - days, Date.today, epics_only, tags).reverse
+    total_entries = logs.sum { |entry| entry.entries.length }
+    _ = total_entries
+    _ = presentation
+
+    [200, {}, [template.result(binding)]]
+  end
+
+  private
+
+  def update_query(new_params)
+    uri = URI.parse('/')
+    cloned = @params.clone
+    new_params.each do |key, value|
+      cloned[key] = value
+    end
+    uri.query = URI.encode_www_form(cloned)
+    uri
+  end
+
+  def build_uri(params)
+    uri = URI.parse('/')
+    uri.query = URI.encode_www_form(params)
+    uri.to_s
+  end
+end
+
+class WorkLogApp
+  def self.call(env)
+    req = Rack::Request.new(env)
+    WorkLogResponse.new.response(req)
+  end
+end
+
+# class FaviconApp
+#   # Rack application that creates a favicon.
+
+#   def self.call(_env)
+#     content = ERB.new(File.read(File.join(File.dirname(__FILE__), 'templates', 'favicon.svg.erb')))
+#     [200, { Rack::CONTENT_TYPE => 'image/svg+xml' }, [content.result]]
+#   end
+# end
+
+class WorkLogServer
+  # Main Rack server containing all endpoints.
+
+  def start
+    app = Rack::Builder.new do
+      use Rack::Deflater
+      use Rack::CommonLogger
+      use Rack::ShowExceptions
+      use Rack::ShowStatus
+      use DefaultHeaderMiddleware
+
+      map '/' do
+        run WorkLogApp
+      end
+      # TODO: Future development
+      # map '/favicon.svg' do
+      #   run FaviconApp
+      # end
+    end
+
+    Rackup::Server.start app: app
+  end
+end

data/worklog/worklog.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative 'hash'
+require_relative 'daily_log'
+require_relative 'log_entry'
+require_relative 'storage'
+
+require 'optparse'
+require 'rainbow'
+require 'yaml'
+
+module Worklog
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: fewald-worklog
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Friedrich Ewald
+bindir: bin
+cert_chain: []
+date: 2025-03-12 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Command line tool for tracking achievments, tasks and interactions.
+
+  You can add work items, view them and run a webserver to share them with other people,
+  for example via screen sharing.
+
+  This tool is designed to run in a terminal completely local without sharing any data with
+  any other service. No telemetry, no tracking, no data sharing of any kind.
+executables:
+- wl
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/wl
+- worklog/cli.rb
+- worklog/daily_log.rb
+- worklog/date_parser.rb
+- worklog/editor.rb
+- worklog/hash.rb
+- worklog/log_entry.rb
+- worklog/logger.rb
+- worklog/person.rb
+- worklog/printer.rb
+- worklog/statistics.rb
+- worklog/storage.rb
+- worklog/string_helper.rb
+- worklog/summary.rb
+- worklog/templates/favicon.svg.erb
+- worklog/templates/index.html.erb
+- worklog/version.rb
+- worklog/webserver.rb
+- worklog/worklog.rb
+homepage: https://github.com/f-ewald/worklog
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://f-ewald.github.io/worklog
+  rubygems_mfa_required: 'true'
+post_install_message: 'Thanks for installing worklog! Now you can use it by running
+  wl from your terminal.''
+
+  '
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.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: Command line tool for tracking achievments, tasks and interactions.
+test_files: []