doing 2.1.18 → 2.1.23

data/bin/doing

@@ -3,6 +3,7 @@
 
 $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
 require 'gli'
+require 'doing/help_monkey_patch'
 require 'doing'
 require 'tempfile'
 require 'pp'
@@ -21,16 +22,12 @@ end
 
 include GLI::App
 include Doing::Errors
+
 version Doing::VERSION
 hide_commands_without_desc true
 autocomplete_commands true
 
-REGEX_BOOL = /^(?:and|all|any|or|not|none|p(?:at(?:tern)?)?)$/i
-REGEX_SORT_ORDER = /^(?:a(?:sc)?|d(?:esc)?)$/i
-REGEX_VALUE_QUERY = /^(?:!)?@?(?:\S+) +(?:!?[<>=][=*]?|[$*^]=) +(?:.*?)$/
-
-InvalidExportType = Class.new(RuntimeError)
-MissingConfigFile = Class.new(RuntimeError)
+include Doing::Types
 
 colors = Doing::Color
 wwid = Doing::WWID.new
@@ -70,7 +67,49 @@ if settings.dig('plugins', 'command_path')
   commands_from File.expand_path(settings.dig('plugins', 'command_path'))
 end
 
-class TagArray < Array; end
+accept TemplateName do |value|
+  res = settings['templates'].keys.select { |k| k =~ value.to_rx(distance: 2) }
+  raise InvalidArgument, "Unknown template: #{value}" if res.empty?
+
+  res.group_by(&:length).min.last[0]
+end
+
+accept DateBeginString do |value|
+  if value =~ REGEX_TIME
+    res = value
+  else
+    res = value.chronify(guess: :begin, future: false)
+  end
+  raise InvalidTimeExpression, 'Invalid start date' unless res
+
+  res
+end
+
+accept DateEndString do |value|
+  if value =~ REGEX_TIME
+    res = value
+  else
+    res = value.chronify(guess: :end, future: false)
+  end
+  raise InvalidTimeExpression, 'Invalid end date' unless res
+
+  res
+end
+
+accept DateRangeString do |value|
+  start, finish = value.split_date_range
+  raise InvalidTimeExpression, 'Invalid range' unless start
+
+  finish ||= Time.now
+  [start, finish]
+end
+
+accept DateIntervalString do |value|
+  res = value.chronify_qty
+  raise InvalidTimeExpression, 'Invalid time quantity' unless res
+
+  res
+end
 
 accept TagArray do |value|
   value.gsub(/[, ]+/, ' ').split(' ').map { |tag| tag.sub(/^@/, '')}.map(&:strip)
@@ -97,7 +136,7 @@ desc 'Use a pager when output is longer than screen'
 switch %i[p pager], default_value: settings['paginate']
 
 desc 'Answer yes/no menus with default option'
-switch [:default], default_value: false
+switch [:default], default_value: false, negatable: false
 
 desc 'Answer all yes/no menus with yes'
 switch [:yes], negatable: false
@@ -143,6 +182,10 @@ command %i[again resume] do |c|
   c.arg_name 'SECTION_NAME'
   c.flag [:in]
 
+  c.desc 'Backdate start date by interval or set to time [4pm|20m|2h|"yesterday noon"]'
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back started], type: DateBeginString
+
   c.desc 'Repeat last entry matching tags. Combine multiple tags with a comma. Wildcards allowed (*, ?)'
   c.arg_name 'TAG'
   c.flag [:tag], type: TagArray
@@ -198,6 +241,13 @@ command %i[again resume] do |c|
       options[:search] = search
     end
 
+    if options[:back]
+      date = options[:back]
+      raise InvalidTimeExpression, 'Unable to parse date string for --back' if date.nil?
+    else
+      date = Time.now
+    end
+
     note = Doing::Note.new(options[:note])
     note.add(Doing::Prompt.read_lines(prompt: 'Add a note')) if options[:ask]
 
@@ -208,6 +258,7 @@ command %i[again resume] do |c|
     opts[:tag] = tags
     opts[:tag_bool] = options[:bool].normalize_bool
     opts[:interactive] = options[:interactive]
+    opts[:date] = date
 
     wwid.repeat_last(opts)
   end
@@ -321,7 +372,7 @@ desc 'Add a completed item with @done(date). No argument finishes last entry'
 long_desc 'Use this command to add an entry after you\'ve already finished it. It will be immediately marked as @done.
 You can modify the start and end times of the entry using the --back, --took, and --at flags, making it an easy
 way to add entries in post and maintain accurate (albeit manual) time tracking.'
-arg_name 'ENTRY'
+arg_name 'ENTRY', optional: true
 command %i[done did] do |c|
   c.example 'doing done', desc: 'Tag the last entry @done'
   c.example 'doing done I already finished this', desc: 'Add a new entry and immediately mark it @done'
@@ -340,24 +391,24 @@ command %i[done did] do |c|
   c.desc %(Set finish date to specific date/time (natural langauge parsed, e.g. --at=1:30pm).
   Used with --took, backdates start date)
   c.arg_name 'DATE_STRING'
-  c.flag %i[at finished]
+  c.flag %i[at finished], type: DateEndString
 
   c.desc 'Backdate start date by interval or set to time [4pm|20m|2h|"yesterday noon"]'
   c.arg_name 'DATE_STRING'
-  c.flag %i[b back started]
+  c.flag %i[b back started], type: DateBeginString
 
   c.desc %(
         Start and end times as a date/time range `doing done --from "1am to 8am"`.
         Overrides other date flags.
       )
   c.arg_name 'TIME_RANGE'
-  c.flag [:from]
+  c.flag [:from], must_match: REGEX_RANGE
 
   c.desc %(Set completion date to start date plus interval (XX[mhd] or HH:MM).
   If used without the --back option, the start date will be moved back to allow
   the completion date to be the current time.)
   c.arg_name 'INTERVAL'
-  c.flag %i[t took for]
+  c.flag %i[t took for], type: DateIntervalString
 
   c.desc 'Section'
   c.arg_name 'NAME'
@@ -385,23 +436,27 @@ command %i[done did] do |c|
     donedate = nil
 
     if options[:from]
-      date, finish_date = options[:from].split_date_range
+      options[:from] = options[:from].split(/#{REGEX_RANGE_INDICATOR}/).map do |time|
+        time =~ REGEX_TIME ? "today #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}" : time
+      end.join(' to ').split_date_range
+      date, finish_date = options[:from]
       finish_date ||= Time.now
     else
       if options[:took]
-        took = options[:took].chronify_qty
+        took = options[:took]
         raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
       end
 
       if options[:back]
-        date = options[:back].chronify(guess: :begin)
+        date = options[:back]
         raise InvalidTimeExpression, 'Unable to parse date string for --back' if date.nil?
       else
         date = options[:took] ? Time.now - took : Time.now
       end
 
       if options[:at]
-        finish_date = options[:at].chronify(guess: :begin)
+        finish_date = options[:at]
+        finish_date = finish_date.chronify(guess: :begin) if finish_date.is_a? String
         raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
         if options[:took]
@@ -417,6 +472,7 @@ command %i[done did] do |c|
     end
 
     if options[:date]
+      date = date.chronify(guess: :begin, context: :today) if date =~ REGEX_TIME
       finish_date = wwid.verify_duration(date, finish_date) unless options[:took] || options[:from]
 
       donedate = finish_date.strftime('%F %R')
@@ -528,7 +584,7 @@ command %i[done did] do |c|
       wwid.content.push(new_entry)
       Doing::Hooks.trigger :post_entry_added, wwid, new_entry.dup
       wwid.write(wwid.doing_file)
-      Doing.logger.info('Entry Added:', new_entry.title)
+      Doing.logger.info('New entry:', %(added "#{new_entry.date.relative_date}: #{new_entry.title}" to #{section}))
     elsif $stdin.stat.size.positive?
       note = Doing::Note.new(options[:note])
       d, title, note = wwid.format_input($stdin.read.strip)
@@ -553,7 +609,7 @@ command %i[done did] do |c|
       Doing::Hooks.trigger :post_entry_added, wwid, new_entry.dup
 
       wwid.write(wwid.doing_file)
-      Doing.logger.info('Entry Added:', new_entry.title)
+      Doing.logger.info('New entry:', %(added "#{new_entry.date.relative_date}: #{new_entry.title}" to #{section}))
     else
       raise EmptyInput, 'You must provide content when creating a new entry'
     end
@@ -563,7 +619,7 @@ end
 # @@finish
 desc 'Mark last X entries as @done'
 long_desc 'Marks the last X entries with a @done tag and current date. Does not alter already completed entries.'
-arg_name 'COUNT'
+arg_name 'COUNT', optional: true
 command :finish do |c|
   c.example 'doing finish', desc: 'Mark the last entry @done'
   c.example 'doing finish --auto --section Later 10', desc: 'Add @done to any unfinished entries in the last 10 in Later, setting the finish time based on the start time of the task after it'
@@ -574,15 +630,15 @@ command :finish do |c|
 
   c.desc 'Backdate completed date to date string [4pm|20m|2h|yesterday noon]'
   c.arg_name 'DATE_STRING'
-  c.flag %i[b back]
+  c.flag %i[b back started], type: DateBeginString
 
   c.desc 'Set the completed date to the start date plus XX[hmd]'
   c.arg_name 'INTERVAL'
-  c.flag %i[t took for]
+  c.flag %i[t took for], type: DateIntervalString
 
   c.desc %(Set finish date to specific date/time (natural langauge parsed, e.g. --at=1:30pm). If used, ignores --back.)
   c.arg_name 'DATE_STRING'
-  c.flag [:at]
+  c.flag %i[at finished], type: DateEndString
 
   c.desc 'Finish the last X entries containing TAG.
   Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool. Wildcards allowed (*, ?).'
@@ -639,7 +695,7 @@ command :finish do |c|
     options[:fuzzy] = false
     unless options[:auto]
       if options[:took]
-        took = options[:took].chronify_qty
+        took = options[:took]
         raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
       end
 
@@ -648,12 +704,13 @@ command :finish do |c|
       raise InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
 
       if options[:at]
-        finish_date = options[:at].chronify(guess: :begin)
+        finish_date = options[:at]
+        finish_date = finish_date.chronify(guess: :begin) if finish_date.is_a? String
         raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
         date = options[:took] ? finish_date - took : finish_date
       elsif options[:back]
-        date = options[:back].chronify()
+        date = options[:back]
 
         raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
       else
@@ -661,8 +718,6 @@ command :finish do |c|
       end
     end
 
-    options[:took] = options[:took].chronify_qty if options[:took]
-
     if options[:tag].nil?
       tags = []
     else
@@ -711,92 +766,6 @@ command :finish do |c|
   end
 end
 
-# @@later
-desc 'Add an item to the Later section'
-arg_name 'ENTRY'
-command :later do |c|
-  c.example 'doing later "Something I\'ll think about tomorrow"', desc: 'Add an entry to the Later section'
-  c.example 'doing later -e', desc: 'Open $EDITOR to create an entry and optional note'
-
-  c.desc "Edit entry with #{Doing::Util.default_editor}"
-  c.switch %i[e editor], negatable: false, default_value: false
-
-  c.desc 'Backdate start time to date string [4pm|20m|2h|yesterday noon]'
-  c.arg_name 'DATE_STRING'
-  c.flag %i[b back]
-
-  c.desc 'Note'
-  c.arg_name 'TEXT'
-  c.flag %i[n note]
-
-  c.desc 'Prompt for note via multi-line input'
-  c.switch %i[ask], negatable: false, default_value: false
-
-  c.action do |_global_options, options, args|
-    if options[:back]
-      date = options[:back].chronify(guess: :begin)
-      raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
-    else
-      date = Time.now
-    end
-
-    ask_note = options[:ask] && !options[:editor] && args.count.positive? ? Doing::Prompt.read_lines(prompt: 'Add a note') : ''
-
-    if options[:editor]
-      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
-
-      input = ''
-      input += date.strftime('%F %R | ')
-      input += args.empty? ? '' : args.join(' ')
-      input += "\n#{options[:note]}" if options[:note]
-      input += "\n#{ask_note}" unless ask_note.empty?
-
-      input = wwid.fork_editor(input).strip
-
-      d, title, note = wwid.format_input(input)
-      raise EmptyInput, 'No content' if title.empty?
-
-      note.add(options[:note]) if options[:note]
-      if ask_note.empty? && options[:ask]
-        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
-        note.add(ask_note) unless ask_note.empty?
-      end
-
-      date = d.nil? ? date : d
-      wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
-      wwid.write(wwid.doing_file)
-    elsif !args.empty?
-      d, title, note = wwid.format_input(args.join(' '))
-      date = d.nil? ? date : d
-      note.add(options[:note]) if options[:note]
-      note.add(ask_note) unless ask_note.empty?
-      wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
-      wwid.write(wwid.doing_file)
-    elsif $stdin.stat.size.positive?
-      d, title, note = wwid.format_input($stdin.read)
-      unless d.nil?
-        Doing.logger.debug('Parser:', 'Date detected in input, overriding command line values')
-        date = d
-      end
-      note.add(options[:note]) if options[:note]
-      note.add(ask_note) unless ask_note.empty?
-      wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
-      wwid.write(wwid.doing_file)
-    else
-      title = Doing::Prompt.read_line(prompt: 'Entry content')
-      raise EmptyInput, 'You must provide content when creating a new entry' if title.strip.empty?
-
-      note = Doing::Note.new
-      res = Doing::Prompt.yn('Add a note', default_response: false)
-      ask_note = res ? Doing::Prompt.read_lines(prompt: 'Enter note') : []
-      note.add(ask_note)
-
-      wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
-      wwid.write(wwid.doing_file)
-    end
-  end
-end
-
 # @@mark @@flag
 desc 'Mark last entry as flagged'
 command %i[mark flag] do |c|
@@ -930,7 +899,7 @@ long_desc 'The @meanwhile tag allows you to have long-running entries that encom
 This command makes it easy to start and stop these overarching entries. Just run `doing meanwhile Starting work on this
 big project` to start a @meanwhile entry, add other entries as you work on the project, then use `doing meanwhile` by
 itself to mark the entry as @done.'
-arg_name 'ENTRY'
+arg_name 'ENTRY', optional: true
 command :meanwhile do |c|
   c.example 'doing meanwhile "Long task that will have others after it before it\'s done"', desc: 'Add a new long-running entry, completing any current @meanwhile entry'
   c.example 'doing meanwhile', desc: 'Finish any open @meanwhile entry'
@@ -949,7 +918,7 @@ command :meanwhile do |c|
 
   c.desc 'Backdate start date for new entry to date string [4pm|20m|2h|yesterday noon]'
   c.arg_name 'DATE_STRING'
-  c.flag %i[b back]
+  c.flag %i[b back started], type: DateBeginString
 
   c.desc 'Note'
   c.arg_name 'TEXT'
@@ -960,7 +929,7 @@ command :meanwhile do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = options[:back].chronify(guess: :begin)
+      date = options[:back]
 
       raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
@@ -1020,7 +989,7 @@ long_desc %(
 
   Use -e to load the last entry in a text editor where you can append a note.
 )
-arg_name 'NOTE_TEXT'
+arg_name 'NOTE_TEXT', optional: true
 command :note do |c|
   c.example 'doing note', desc: 'Open the last entry in $EDITOR to append a note'
   c.example 'doing note "Just a quick annotation"', desc: 'Add a quick note to the last entry'
@@ -1088,7 +1057,6 @@ command :note do |c|
       options[:search] = search
     end
 
-
     last_entry = wwid.last_entry(options)
 
     unless last_entry
@@ -1098,37 +1066,37 @@ command :note do |c|
 
     last_note = last_entry.note || Doing::Note.new
     new_note = Doing::Note.new
-    ask_note = options[:ask] ? Doing::Prompt.read_lines(prompt: 'Add a note') : ''
 
-    if options[:editor] || (args.empty? && $stdin.stat.size.zero? && !options[:remove] && !options[:ask])
-      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+    if $stdin.stat.size.positive?
+      new_note.add($stdin.read.strip)
+    end
+
+    unless args.empty?
+      new_note.add(args.join(' '))
+    end
 
-      input = !args.empty? ? args.join(' ') : ''
+    if options[:editor]
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       if options[:remove]
-        prev_input = Doing::Note.new
+        input = Doing::Note.new
       else
-        prev_input = last_entry.note || Doing::Note.new
+        input = last_entry.note || Doing::Note.new
       end
 
+      input.add(new_note)
 
-      input = prev_input.add(input)
-      input.add(ask_note) unless ask_note.empty?
-
-      input = wwid.fork_editor(prev_input.strip_lines.join("\n"), message: nil).strip
-      note = input
+      new_note = Doing::Note.new(wwid.fork_editor(input.strip_lines.join("\n"), message: nil).strip)
       options[:remove] = true
-      new_note.add(note)
-    elsif !args.empty?
-      new_note.add(args.join(' '))
-    elsif $stdin.stat.size.positive?
-      new_note.add($stdin.read.strip)
-    else
-      raise EmptyInput, 'You must provide content when adding a note' unless options[:remove] || !ask_note.empty?
+    end
 
+    if (new_note.empty? && !options[:remove]) || options[:ask]
+      $stderr.puts last_note unless last_note.empty?
+      $stderr.puts new_note unless new_note.empty?
+      new_note.add(Doing::Prompt.read_lines(prompt: 'Add a note'))
     end
 
-    new_note.add(ask_note) unless ask_note.empty?
+    raise EmptyInput, 'You must provide content when adding a note' unless options[:remove] || !new_note.empty?
 
     if last_note.equal?(new_note)
       Doing.logger.debug('Skipped:', 'No note change')
@@ -1169,7 +1137,7 @@ command %i[now next] do |c|
 
   c.desc 'Backdate start time [4pm|20m|2h|"yesterday noon"]'
   c.arg_name 'DATE_STRING'
-  c.flag %i[b back started]
+  c.flag %i[b back started], type: DateBeginString
 
   c.desc 'Timed entry, marks last entry in section as @done'
   c.switch %i[f finish_last], negatable: false, default_value: false
@@ -1187,7 +1155,7 @@ command %i[now next] do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = options[:back].chronify(guess: :begin)
+      date = options[:back]
 
       raise InvalidTimeExpression.new('unable to parse date string', topic: 'Parser:') if date.nil?
     else
@@ -1211,7 +1179,7 @@ command %i[now next] do |c|
       input += "\n#{ask_note}" unless ask_note.empty?
       input = wwid.fork_editor(input).strip
 
-      date, title, note = wwid.format_input(input)
+      d, title, note = wwid.format_input(input)
       raise EmptyInput, 'No content' if title.strip.empty?
 
       if ask_note.empty? && options[:ask]
@@ -1219,6 +1187,7 @@ command %i[now next] do |c|
         note.add(ask_note) unless ask_note.empty?
       end
 
+      date = d.nil? ? date : d
       wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
       wwid.write(wwid.doing_file)
     elsif args.length.positive?
@@ -1265,7 +1234,7 @@ desc 'Reset the start time of an entry'
 long_desc 'Update the start time of the last entry or the last entry matching a tag/search filter.
 If no argument is provided, the start time will be reset to the current time.
 If a date string is provided as an argument, the start time will be set to the parsed result.'
-arg_name 'DATE_STRING'
+arg_name 'DATE_STRING', optional: true
 command %i[reset begin] do |c|
   c.example 'doing reset', desc: 'Reset the start time of the last entry to the current time'
   c.example 'doing reset --tag project1', desc: 'Reset the start time of the most recent entry tagged @project1 to the current time'
@@ -1279,6 +1248,9 @@ command %i[reset begin] do |c|
   c.desc 'Resume entry (remove @done)'
   c.switch %i[r resume], default_value: true
 
+  c.desc 'Change start date but do not remove @done (shortcut for --no-resume)'
+  c.switch [:n]
+
   c.desc 'Reset last entry matching tag. Wildcards allowed (*, ?)'
   c.arg_name 'TAG'
   c.flag [:tag]
@@ -1416,11 +1388,11 @@ command :select do |c|
 
   c.desc 'Select from entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateBeginString
 
   c.desc 'Select from entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:after]
+  c.flag [:after], type: DateEndString
 
   c.desc %(
       Date range to show, or a single day to filter date on.
@@ -1431,7 +1403,7 @@ command :select do |c|
       by time of day.
     )
   c.arg_name 'DATE_OR_RANGE'
-  c.flag [:from]
+  c.flag [:from], type: DateRangeString
 
   c.desc 'Force exact search string matching (case sensitive)'
   c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
@@ -1698,11 +1670,11 @@ command %i[grep search] do |c|
 
   c.desc 'Search entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateBeginString
 
   c.desc 'Search entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:after]
+  c.flag [:after], type: DateEndString
 
   c.desc %(
       Date range to show, or a single day to filter date on.
@@ -1713,12 +1685,20 @@ command %i[grep search] do |c|
       by time of day.
     )
   c.arg_name 'DATE_OR_RANGE'
-  c.flag [:from]
+  c.flag [:from], type: DateRangeString
 
   c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
   c.flag %i[o output]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'default'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
@@ -1773,7 +1753,7 @@ command %i[grep search] do |c|
     options[:fuzzy] = false
     raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
 
-    template = settings['templates']['default'].deep_merge(settings)
+    template = settings['templates'][options[:config_template]].deep_merge(settings)
     tags_color = template.key?('tags_color') ? template['tags_color'] : nil
 
     section = wwid.guess_section(options[:section]) if options[:section]
@@ -1830,6 +1810,14 @@ command :last do |c|
   c.arg_name 'QUERY'
   c.flag [:search]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'last'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc "Highlight search matches in output. Only affects command line output"
   c.switch %i[h hilite], default_value: settings.dig('search', 'highlight')
 
@@ -1883,6 +1871,8 @@ command :last do |c|
     else
       last = wwid.last(times: true, section: options[:section],
                      options: {
+                        config_template: options[:config_template],
+                        template: options[:template],
                         duration: options[:duration],
                         search: options[:search],
                         fuzzy: options[:fuzzy],
@@ -1917,6 +1907,14 @@ command :recent do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'recent'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc 'Show elapsed time on entries without @done tag'
   c.switch [:duration]
 
@@ -1960,7 +1958,9 @@ command :recent do |c|
         times: options[:times],
         totals: options[:totals],
         interactive: options[:interactive],
-        duration: options[:duration]
+        duration: options[:duration],
+        config_template: options[:config_template],
+        template: options[:template]
       }
 
       Doing::Pager::page wwid.recent(count, section.cap_first, opts)
@@ -2011,11 +2011,11 @@ command :show do |c|
 
   c.desc 'Show entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateBeginString
 
   c.desc 'Show entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:after]
+  c.flag [:after], type: DateEndString
 
   c.desc %(
       Date range to show, or a single day to filter date on.
@@ -2027,7 +2027,7 @@ command :show do |c|
     )
 
   c.arg_name 'DATE_OR_RANGE'
-  c.flag [:from]
+  c.flag [:from], type: DateRangeString
 
   c.desc 'Search filter, surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
@@ -2075,6 +2075,14 @@ command :show do |c|
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'default'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc 'Select section or tag to display from a menu'
   c.switch %i[m menu], negatable: false, default_value: false
 
@@ -2131,7 +2139,7 @@ command :show do |c|
 
     options[:times] = true if options[:totals]
 
-    template = settings['templates']['default'].deep_merge({
+    template = settings['templates'][options[:config_template]].deep_merge({
         'wrap_width' => settings['wrap_width'] || 0,
         'date_format' => settings['default_date_format'],
         'order' => settings['order'] || 'asc',
@@ -2195,6 +2203,7 @@ end
 
 # @@tags
 desc 'List all tags in the current Doing file'
+arg_name 'MAX_COUNT', optional: true, type: Integer
 command :tags do |c|
   c.desc 'Section'
   c.arg_name 'SECTION_NAME'
@@ -2203,6 +2212,9 @@ command :tags do |c|
   c.desc 'Show count of occurrences'
   c.switch %i[c counts]
 
+  c.desc 'Output in a single line with @ symbols. Ignored if --counts is specified.'
+  c.switch %i[l line]
+
   c.desc 'Sort by name or count'
   c.arg_name 'SORT_ORDER'
   c.flag %i[sort], default_value: 'name', must_match: /^(?:n(?:ame)?|c(?:ount)?)$/
@@ -2246,6 +2258,7 @@ command :tags do |c|
 
   c.action do |_global, options, args|
     section = wwid.guess_section(options[:section]) || options[:section].cap_first
+    options[:count] = args.count.positive? ? args[0].to_i : 0
 
     items = wwid.filter_items([], opt: options)
 
@@ -2273,7 +2286,11 @@ command :tags do |c|
     if options[:counts]
       tags.each { |t, c| puts "#{t} (#{c})" }
     else
-      tags.each { |t, c| puts "#{t}" }
+      if options[:line]
+        puts tags.map { |t, c| t }.to_tags.join(' ')
+      else
+        tags.each { |t, c| puts "#{t}" }
+      end
     end
   end
 end
@@ -2311,6 +2328,14 @@ command :today do |c|
   c.arg_name 'FORMAT'
   c.flag %i[o output]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'today'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc 'View entries before specified time (e.g. 8am, 12:30pm, 15:00)'
   c.arg_name 'TIME_STRING'
   c.flag [:before]
@@ -2322,21 +2347,21 @@ command :today do |c|
   c.desc %(
     Time range to show `doing today --from "12pm to 4pm"`
   )
-  c.arg_name 'DATE_OR_RANGE'
-  c.flag [:from]
+  c.arg_name 'TIME_RANGE'
+  c.flag [:from], type: DateRangeString
 
   c.action do |_global_options, options, _args|
     raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
 
     options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
-    filter_options = %i[after before duration from section sort_tags totals].each_with_object({}) { |k, hsh| hsh[k] = options[k] }
+    filter_options = %i[after before duration from section sort_tags totals template config_template].each_with_object({}) { |k, hsh| hsh[k] = options[k] }
 
     Doing::Pager.page wwid.today(options[:times], options[:output], filter_options).chomp
   end
 end
 
-# @on
+# @@on
 desc 'List entries for a date'
 long_desc %(Date argument can be natural language. "thursday" would be interpreted as "last thursday,"
 and "2d" would be interpreted as "two days ago." If you use "to" or "through" between two dates,
@@ -2370,21 +2395,24 @@ command :on do |c|
   c.arg_name 'FORMAT'
   c.flag %i[o output]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'default'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.action do |_global_options, options, args|
     raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
 
     raise MissingArgument, 'Missing date argument' if args.empty?
 
-    date_string = args.join(' ')
-
-    if date_string =~ / (to|through|thru) /
-      dates = date_string.split(/ (to|through|thru) /)
-      start = dates[0].chronify(guess: :begin)
-      finish = dates[2].chronify(guess: :end)
-    else
-      start = date_string.chronify(guess: :begin)
-      finish = false
+    date_string = args.join(' ').strip
+    if date_string =~ /^tod(?:ay)?/i
+      date_string = 'today to tomorrow 12am'
     end
+    start, finish = date_string.split_date_range
 
     raise InvalidTimeExpression, 'Unrecognized date string' unless start
 
@@ -2396,7 +2424,7 @@ command :on do |c|
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
     Doing::Pager.page wwid.list_date([start, finish], options[:section], options[:times], options[:output],
-                        { duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+                        { template: options[:template], config_template: options[:config_template], duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
@@ -2432,6 +2460,14 @@ command :since do |c|
   c.arg_name 'FORMAT'
   c.flag %i[o output]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'default'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.action do |_global_options, options, args|
     raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
 
@@ -2453,7 +2489,7 @@ command :since do |c|
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
     Doing::Pager.page wwid.list_date([start, finish], options[:section], options[:times], options[:output],
-                        { duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+                        { template: options[:template], config_template: options[:config_template], duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
@@ -2536,11 +2572,11 @@ command :view do |c|
 
   c.desc 'View entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateBeginString
 
   c.desc 'View entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day'
   c.arg_name 'DATE_STRING'
-  c.flag [:after]
+  c.flag [:after], type: DateEndString
 
   c.desc %(
       Date range to show, or a single day to filter date on.
@@ -2551,7 +2587,7 @@ command :view do |c|
       by time of day.
     )
   c.arg_name 'DATE_OR_RANGE'
-  c.flag [:from]
+  c.flag [:from], type: DateRangeString
 
   c.desc 'Only show items with recorded time intervals (override view settings)'
   c.switch [:only_timed], default_value: false, negatable: false
@@ -2588,17 +2624,17 @@ command :view do |c|
     view = wwid.get_view(title)
 
     if view
-      page_title = view.key?('title') ? view['title'] : title.cap_first
+      page_title = view['title'] || title.cap_first
       only_timed = if (view.key?('only_timed') && view['only_timed']) || options[:only_timed]
                      true
                    else
                      false
                    end
 
-      template = view.key?('template') ? view['template'] : nil
-      date_format = view.key?('date_format') ? view['date_format'] : nil
+      template = view['template'] || nil
+      date_format = view['date_format'] || nil
 
-      tags_color = view.key?('tags_color') ? view['tags_color'] : nil
+      tags_color = view['tags_color'] || nil
       tag_filter = false
       if options[:tag]
         tag_filter = { 'tags' => [], 'bool' => 'OR' }
@@ -2628,19 +2664,19 @@ command :view do |c|
       section = if options[:section]
                   section
                 else
-                  view.key?('section') ? view['section'] : settings['current_section']
+                  view['section'] || settings['current_section']
                 end
-      order = view.key?('order') ? view['order'].normalize_order : 'asc'
+      order = view['order']&.normalize_order || 'asc'
 
       totals = if options[:totals]
                  true
                else
-                 view.key?('totals') ? view['totals'] : false
+                 view['totals'] || false
                end
       tag_order = if options[:tag_order]
                     options[:tag_order].normalize_order
                   else
-                    view.key?('tag_order') ? view['tag_order'].normalize_order : 'asc'
+                    view['tag_order']&.normalize_order || 'asc'
                   end
 
       options[:times] = true if totals
@@ -2669,7 +2705,6 @@ command :view do |c|
 
       opts = options.dup
       opts[:age] = options[:age].normalize_age(:newest)
-      opts[:view_template] = title
       opts[:count] = count
       opts[:format] = date_format
       opts[:highlight] = options[:color]
@@ -2686,6 +2721,7 @@ command :view do |c|
       opts[:tags_color] = tags_color
       opts[:template] = template
       opts[:totals] = totals
+      opts[:view_template] = title
 
       Doing::Pager.page wwid.list_section(opts)
     elsif title.instance_of?(FalseClass)
@@ -2713,6 +2749,14 @@ command :yesterday do |c|
   c.arg_name 'FORMAT'
   c.flag %i[o output]
 
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'today'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
@@ -2735,11 +2779,9 @@ command :yesterday do |c|
   c.arg_name 'TIME_STRING'
   c.flag [:after]
 
-  c.desc %(
-      Time range to show, e.g. `doing yesterday --from "1am to 8am"`
-    )
+  c.desc 'Time range to show, e.g. `doing yesterday --from "1am to 8am"`'
   c.arg_name 'TIME_RANGE'
-  c.flag [:from]
+  c.flag [:from], must_match: REGEX_TIME_RANGE
 
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
@@ -2751,21 +2793,15 @@ command :yesterday do |c|
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
     if options[:from]
-      options[:from] = options[:from].split(/ (?:to|through|thru|(?:un)?til|-+) /).map do |time|
+      options[:from] = options[:from].split(/#{REGEX_RANGE_INDICATOR}/).map do |time|
         "yesterday #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}"
-      end.join(' to ')
-    end
-
-    opt = {
-      after: options[:after],
-      before: options[:before],
-      duration: options[:duration],
-      from: options[:from],
-      sort_tags: options[:sort_tags],
-      tag_order: options[:tag_order].normalize_order,
-      totals: options[:totals],
-      order: settings.dig('templates', 'today', 'order')
-    }
+      end.join(' to ').split_date_range
+    end
+
+    opt = options.dup
+    opt[:tag_order] = options[:tag_order].normalize_order
+    opt[:order] = settings.dig('templates', options[:config_template], 'order')
+
     Doing::Pager.page wwid.yesterday(options[:section], options[:times], options[:output], opt).chomp
   end
 end
@@ -2991,8 +3027,7 @@ command :config do |c|
       value = options[:remove] ? nil : args.pop
       keypath = args.join('.')
       real_path = config.resolve_key_path(keypath, create: true)
-
-      old_value = settings.dig(*real_path) || nil
+      old_value = settings.dig(*real_path)
       old_type = old_value&.class.to_s || nil
 
       if old_value.is_a?(Hash) && !options[:remove]
@@ -3018,7 +3053,6 @@ command :config do |c|
       else
         current_value = cfg.dig(*real_path)
         cfg.deep_set(real_path, value.set_type(old_type))
-
         $stderr.puts "#{' Key path:'.yellow} #{real_path.join('->').boldwhite}"
         $stderr.puts "#{'Inherited:'.yellow} #{(old_value ? old_value.to_s : 'empty').boldwhite}"
         $stderr.puts "#{'  Current:'.yellow} #{ (current_value ? current_value.to_s : 'empty').boldwhite }"
@@ -3178,7 +3212,7 @@ command %i[archive move] do |c|
   c.desc 'Archive entries older than date
     (Flexible date format, e.g. 1/27/2021, 2020-07-19, or Monday 3pm)'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateEndString
 
   c.action do |_global_options, options, args|
     options[:fuzzy] = false
@@ -3269,11 +3303,11 @@ command :import do |c|
   # TODO: Allow time range filtering
   c.desc 'Import entries older than date'
   c.arg_name 'DATE_STRING'
-  c.flag [:before]
+  c.flag [:before], type: DateBeginString
 
   c.desc 'Import entries newer than date'
   c.arg_name 'DATE_STRING'
-  c.flag [:after]
+  c.flag [:after], type: DateEndString
 
   c.desc %(
     Date range to import. Date range argument should be quoted. Date specifications can be natural language.
@@ -3281,7 +3315,7 @@ command :import do |c|
     Has no effect unless the import plugin has implemented date range filtering.
   )
   c.arg_name 'DATE_OR_RANGE'
-  c.flag %i[f from]
+  c.flag %i[f from], type: DateRangeString
 
   c.desc 'Allow entries that overlap existing times'
   c.switch [:overlap], negatable: true
@@ -3299,24 +3333,19 @@ command :import do |c|
     end
 
     if options[:from]
-      date_string = options[:from]
-      if date_string =~ / (to|through|thru|(un)?til|-+) /
-        dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-        start = dates[0].chronify(guess: :begin)
-        finish = dates[2].chronify(guess: :end)
-      else
-        start = date_string.chronify(guess: :begin)
-        finish = date_string.chronify(guess: :end)
-      end
-      raise InvalidTimeExpression, 'Unrecognized date string' unless start
-      dates = [start, finish]
+      options[:date_filter] = options[:from]
+
+      raise InvalidTimeExpression, 'Unrecognized date string' unless options[:date_filter][0]
+    elsif options[:before] || options[:after]
+      options[:date_filter] = [nil, nil]
+      options[:date_filter][1] = options[:before] || Time.now + (1 << 64)
+      options[:date_filter][0] = options[:after] || Time.now - (1 << 64)
     end
 
     options[:case] = options[:case].normalize_case
 
     if options[:type] =~ Doing::Plugins.plugin_regex(type: :import)
       options[:no_overlap] = !options[:overlap]
-      options[:date_filter] = dates
       wwid.import(args, options)
       wwid.write(wwid.doing_file)
     else
@@ -3633,17 +3662,44 @@ end
 
 # @@changelog @@changes
 desc 'List recent changes in Doing'
-long_desc 'Display a formatted list of changes in recent versions, latest at the top'
-command %i[changelog changes] do |c|
+long_desc %(Display a formatted list of changes in recent versions.
+
+            Without flags, displays only the most recent version.
+            Use --lookup or --all for history.)
+command %i[changes changelog] do |c|
+  c.desc 'Display all versions'
+  c.switch %i[a all], default_value: false, negatable: false
+
+  c.desc %(Look up a specific version. Specify versions as "MAJ.MIN.PATCH", MIN
+           and PATCH are optional. Use > or < to see all changes since or prior
+           to a version.)
+  c.arg_name 'VERSION'
+  c.flag %i[l lookup], must_match: /^(?:(?:(?:[<>=]|p(?:rior)|b(?:efore)|o(?:lder)|s(?:ince)|a(?:fter)|n(?:ewer))? *[\d.*?]+ *)+|(?:[\d.]+ *-+ *[\d.]+))$/
+
+  c.desc %(Show changelogs matching search terms (uses pattern-based searching).
+           Add slashes to search with regular expressions, e.g. `--search "/output.*flag/"`)
+  c.flag %i[s search]
+
+  c.example 'doing changes', desc: 'View changes in the current version'
+  c.example 'doing changes --all', desc: 'See the entire changelog'
+  c.example 'doing changes --lookup 2.0.21', desc: 'See changes from version 2.0.21'
+  c.example 'doing changes --lookup "> 2.1"', desc: 'See all changes since 2.1.0'
+  c.example 'doing changes --search "tags +bool"', desc: 'See all changes containing "tags" and "bool"'
+  c.example 'doing changes -l "> 2.1" -s "pattern"', desc: 'Lookup and search can be combined'
+
+
   c.action do |_global_options, options, args|
-    changelog = File.expand_path(File.join(File.dirname(__FILE__), '..', 'CHANGELOG.md'))
-    if File.exist?(changelog)
-      parsed = TTY::Markdown.parse(IO.read(changelog), width: 80, symbols: {override: {bullet: "•"}})
-      Doing::Pager.paginate = true
-      Doing::Pager.page parsed
-    else
-      raise "Error locating changelog"
-    end
+    cl = Doing::Changes.new(lookup: options[:lookup], search: options[:search])
+
+    content = if options[:all] || options[:search] || options[:lookup]
+                cl.to_s
+              else
+                cl.latest
+              end
+
+    parsed = TTY::Markdown.parse(content, width: 80, symbols: {override: {bullet: "•"}})
+    Doing::Pager.paginate = true
+    Doing::Pager.page parsed
   end
 end
 
@@ -3667,9 +3723,9 @@ command :commands_accepting do |c|
       end
 
       if o[:column]
-        puts cmds
+        puts cmds.sort
       else
-        puts "Commands accepting --#{option}: #{cmds.join(', ')}"
+        puts "Commands accepting --#{option}: #{cmds.sort.join(', ')}"
       end
     end
   end
@@ -3700,7 +3756,7 @@ pre do |global, _command, _options, _args|
   Doing::Pager.paginate = global[:pager]
 
   $stdout.puts "doing v#{Doing::VERSION}" if global[:version]
-  unless STDOUT.isatty
+  unless $stdout.isatty
     Doing::Color.coloring = global[:pager] ? global[:color] : false
   else
     Doing::Color.coloring = global[:color]
@@ -3714,7 +3770,9 @@ pre do |global, _command, _options, _args|
 end
 
 on_error do |exception|
-  if exception.kind_of?(SystemExit)
+  if exception.kind_of?(GLI::UnknownCommand)
+    exit run(['now'].concat(ARGV))
+  elsif exception.kind_of?(SystemExit)
     false
   else
     # Doing.logger.error('Fatal:', exception)
@@ -3748,7 +3806,12 @@ around do |global, command, options, arguments, code|
     Doing::Prompt.force_answer = false
     Doing.config.force_answer = false
   else
-    Doing::Prompt.default_answer = global[:default]
+    Doing::Prompt.default_answer = if $stdout.isatty
+                                     global[:default]
+                                   else
+                                     true
+                                   end
+
     Doing.config.force_answer = global[:default] ? true : false
   end