doing 2.1.0pre → 2.1.4pre

data/bin/doing

@@ -25,7 +25,7 @@ version Doing::VERSION
 hide_commands_without_desc true
 autocomplete_commands true
 
-REGEX_BOOL = /^(?:and|all|any|or|not|none)$/i
+REGEX_BOOL = /^(?:and|all|any|or|not|none|p(?:at(?:tern)?)?)$/i
 REGEX_SORT_ORDER = /^(?:a(?:sc)?|d(?:esc)?)$/i
 
 InvalidExportType = Class.new(RuntimeError)
@@ -146,9 +146,9 @@ command %i[now next] do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
 
-      raise InvalidTimeExpression.new('unable to parse date string', topic: 'Date parser:') if date.nil?
+      raise InvalidTimeExpression.new('unable to parse date string', topic: 'Parser:') if date.nil?
     else
       date = Time.now
     end
@@ -195,7 +195,16 @@ command %i[now next] do |c|
 end
 
 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'
 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'
+  c.example 'doing reset 3pm', desc: 'Reset the start time of the last entry to 3pm of the current day'
+  c.example 'doing begin --tag todo --resume', desc: 'alias for reset. Updates the last @todo entry to the current time, removing @done tag.'
+
   c.desc 'Limit search to section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -203,7 +212,7 @@ command %i[reset begin] do |c|
   c.desc 'Resume entry (remove @done)'
   c.switch %i[r resume], default_value: true
 
-  c.desc 'Reset last entry matching tag'
+  c.desc 'Reset last entry matching tag. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -226,12 +235,19 @@ command %i[reset begin] do |c|
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Select from a menu of matching entries'
   c.switch %i[i interactive], negatable: false, default_value: false
 
   c.action do |global_options, options, args|
+    if args.count > 0
+      reset_date = args.join(' ').chronify(guess: :begin)
+      raise InvalidArgument, 'Invalid date string' unless reset_date
+    else
+      reset_date = Time.now
+    end
+
     options[:fuzzy] = false
     if options[:section]
       options[:section] = wwid.guess_section(options[:section]) || options[:section].cap_first
@@ -259,7 +275,7 @@ command %i[reset begin] do |c|
         sort: false,
         show_if_single: true)
     else
-      last_entry = items.last
+      last_entry = items.reverse.last
     end
 
     unless last_entry
@@ -267,7 +283,7 @@ command %i[reset begin] do |c|
       return
     end
 
-    wwid.reset_item(last_entry, resume: options[:resume])
+    wwid.reset_item(last_entry, date: reset_date, resume: options[:resume])
 
     # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
 
@@ -301,7 +317,7 @@ command :note do |c|
   c.desc "Replace/Remove last entry's note (default append)"
   c.switch %i[r remove], negatable: false, default_value: false
 
-  c.desc 'Add/remove note from last entry matching tag'
+  c.desc 'Add/remove note from last entry matching tag. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -322,9 +338,9 @@ command :note do |c|
   c.arg_name 'TYPE'
   c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
 
-  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Select item for new note from a menu of matching entries'
   c.switch %i[i interactive], negatable: false, default_value: false
@@ -394,6 +410,10 @@ command :note do |c|
 end
 
 desc 'Finish any running @meanwhile tasks and optionally create a new one'
+long_desc 'The @meanwhile tag allows you to have long-running entries that encompass smaller entries.
+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'
 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'
@@ -421,7 +441,7 @@ command :meanwhile do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
 
       raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
@@ -521,8 +541,19 @@ long_desc 'List all entries and select with typeahead fuzzy matching.
 
 Multiple selections are allowed, hit tab to add the highlighted entry to the
 selection, and use ctrl-a to select all visible items. Return processes the
-selected entries.'
+selected entries.
+
+Search in the menu by typing:
+
+sbtrkt  fuzzy-match   Items that match sbtrkt
+
+\'wild   exact-match (quoted)  Items that include wild
+
+!fire   inverse-exact-match   Items that do not include fire'
 command :select do |c|
+  c.example 'doing select', desc: 'Select from all entries. A menu of available actions will be presented after confirming the selection.'
+  c.example 'doing select --editor', desc: 'Select entries from a menu and batch edit them in your default editor'
+  c.example 'doing select --after "yesterday 12pm" --tag project1', desc: 'Display a menu of entries created after noon yesterday, add @project1 to selected entries'
   c.desc 'Select from a specific section'
   c.arg_name 'SECTION'
   c.flag %i[s section]
@@ -548,6 +579,25 @@ command :select do |c|
   c.arg_name 'QUERY'
   c.flag %i[q query search]
 
+  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.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.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing select --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Force exact search string matching (case sensitive)'
   c.switch %i[x exact], default_value: false, negatable: false
 
@@ -620,7 +670,7 @@ command :later do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
       raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
       date = Time.now
@@ -661,6 +711,9 @@ command :later do |c|
 end
 
 desc 'Add a completed item with @done(date). No argument finishes last entry.'
+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'
 command %i[done did] do |c|
   c.example 'doing done', desc: 'Tag the last entry @done'
@@ -715,19 +768,19 @@ command %i[done did] do |c|
     donedate = nil
 
     if options[:took]
-      took = wwid.chronify_qty(options[:took])
+      took = options[:took].chronify_qty
       raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
     end
 
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
       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 = wwid.chronify(options[:at], guess: :begin)
+      finish_date = options[:at].chronify(guess: :begin)
       raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
       date = options[:took] ? finish_date - took : finish_date
@@ -871,13 +924,13 @@ command :cancel do |c|
   c.arg_name 'NAME'
   c.flag %i[s section]
 
-  c.desc 'Cancel the last X entries containing TAG. Separate multiple tags with comma (--tag=tag1,tag2)'
+  c.desc 'Cancel the last X entries containing TAG. Separate multiple tags with comma (--tag=tag1,tag2). Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Cancel the last X entries matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
@@ -978,7 +1031,7 @@ command :finish do |c|
   c.flag [:at]
 
   c.desc 'Finish the last X entries containing TAG.
-  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool'
+  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -999,9 +1052,9 @@ command :finish do |c|
   c.arg_name 'TYPE'
   c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
 
-  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Remove done tag'
   c.switch %i[r remove], negatable: false, default_value: false
@@ -1028,7 +1081,7 @@ command :finish do |c|
     options[:fuzzy] = false
     unless options[:auto]
       if options[:took]
-        took = wwid.chronify_qty(options[:took])
+        took = options[:took].chronify_qty
         raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
       end
 
@@ -1037,21 +1090,21 @@ command :finish do |c|
       raise InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
 
       if options[:at]
-        finish_date = wwid.chronify(options[:at], guess: :begin)
+        finish_date = options[:at].chronify(guess: :begin)
         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 = wwid.chronify(options[:back])
+        date = options[:back].chronify()
 
         raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
-      elsif options[:took]
-        date = wwid.chronify_qty(options[:took])
       else
         date = Time.now
       end
     end
 
+    options[:took] = options[:took].chronify_qty if options[:took]
+
     if options[:tag].nil?
       tags = []
     else
@@ -1091,6 +1144,7 @@ command :finish do |c|
       tag: tags,
       tag_bool: options[:bool].normalize_bool,
       tags: ['done'],
+      took: options[:took],
       unfinished: options[:unfinished]
     }
 
@@ -1099,7 +1153,14 @@ command :finish do |c|
 end
 
 desc 'Repeat last entry as new entry'
+long_desc 'This command is designed to allow multiple time intervals to be created for an entry by duplicating it with a new start (and end, eventually) time.'
 command %i[again resume] do |c|
+  c.example 'doing resume', desc: 'Duplicate the most recent entry with a new start time, removing any @done tag'
+  c.example 'doing again', desc: 'again is an alias for resume'
+  c.example 'doing resume --editor', desc: 'Repeat the last entry, opening the new entry in the default editor'
+  c.example 'doing resume --tag project1 --in Projects', desc: 'Repeat the last entry tagged @project1, creating the new entry in the Projects section'
+  c.example 'doing resume --interactive', desc: 'Select the entry to repeat from a menu'
+
   c.desc 'Get last entry from a specific section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1108,7 +1169,7 @@ command %i[again resume] do |c|
   c.arg_name 'SECTION_NAME'
   c.flag [:in]
 
-  c.desc 'Repeat last entry matching tags. Combine multiple tags with a comma.'
+  c.desc 'Repeat last entry matching tags. Combine multiple tags with a comma. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -1130,9 +1191,9 @@ command %i[again resume] do |c|
   c.arg_name 'TYPE'
   c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
 
-  c.desc 'Boolean used to combine multiple tags'
+  c.desc 'Boolean used to combine multiple tags. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc "Edit duplicated entry with #{Doing::Util.default_editor} before adding"
   c.switch %i[e editor], negatable: false, default_value: false
@@ -1166,6 +1227,46 @@ command %i[again resume] do |c|
   end
 end
 
+desc 'List all tags in the current Doing file'
+command :tags do |c|
+  c.desc 'Section'
+  c.arg_name 'SECTION_NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc 'Show count of occurrences'
+  c.switch %i[c counts]
+
+  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)?)$/
+
+  c.desc 'Sort order (asc/desc)'
+  c.arg_name 'ORDER'
+  c.flag %i[o order], must_match: REGEX_SORT_ORDER, default_value: 'asc'
+
+  c.action do |_global, options, args|
+    section = wwid.guess_section(options[:section]) || options[:section].cap_first
+
+    items = wwid.content.in_section(section)
+    tags = wwid.all_tags(items, counts: true)
+
+    if options[:sort] =~ /^n/i
+      tags = tags.sort_by { |tag, count| tag }
+    else
+      tags = tags.sort_by { |tag, count| count }
+    end
+
+    tags.reverse! if options[:order].normalize_order == 'desc'
+
+    if options[:counts]
+      tags.each { |t, c| puts "#{t} (#{c})" }
+    else
+      tags.each { |t, c| puts "#{t}" }
+    end
+  end
+end
+
+
 desc 'Add tag(s) to last entry'
 long_desc 'Add (or remove) tags from the last entry, or from multiple entries
           (with `--count`), entries matching a search (with `--search`), or entries
@@ -1219,7 +1320,7 @@ command :tag do |c|
   c.switch %i[a autotag], negatable: false, default_value: false
 
   c.desc 'Tag the last X entries containing TAG.
-  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool'
+  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -1240,9 +1341,9 @@ command :tag do |c|
   c.arg_name 'TYPE'
   c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
 
-  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Select item(s) to tag from a menu of matching entries'
   c.switch %i[i interactive], negatable: false, default_value: false
@@ -1330,8 +1431,9 @@ command :tag do |c|
 end
 
 desc 'Mark last entry as flagged'
-command [:mark, :flag] do |c|
+command %i[mark flag] do |c|
   c.example 'doing flag', desc: 'Add @flagged to the last entry created'
+  c.example 'doing mark', desc: 'mark is an alias for flag'
   c.example 'doing flag --tag project1 --count 2', desc: 'Add @flagged to the last 2 entries tagged @project1'
   c.example 'doing flag --interactive --search "/(develop|cod)ing/"', desc: 'Find entries matching regular expression and create a menu allowing multiple selections, selected items will be @flagged'
 
@@ -1356,7 +1458,7 @@ command [:mark, :flag] do |c|
   c.switch %i[u unfinished], negatable: false, default_value: false
 
   c.desc 'Flag the last entry containing TAG.
-  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool'
+  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
@@ -1377,9 +1479,9 @@ command [:mark, :flag] do |c|
   c.arg_name 'TYPE'
   c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
 
-  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Select item(s) to flag from a menu of matching entries'
   c.switch %i[i interactive], negatable: false, default_value: false
@@ -1453,7 +1555,11 @@ end
 desc 'List all entries'
 long_desc %(
   The argument can be a section name, @tag(s) or both.
-  "pick" or "choose" as an argument will offer a section menu.
+  "pick" or "choose" as an argument will offer a section menu. Run with `--menu` to get a menu of available tags.
+
+  Show tags by passing @tagname arguments. Multiple tags can be combined, and you can specify the boolean used to
+  combine them with `--bool (AND|OR|NOT)`. You can also use @+tagname to require a tag to match, or @-tagname to ignore
+  entries containing tagname. +/- operators require `--bool PATTERN` (which is the default).
 )
 arg_name '[SECTION|@TAGS]'
 command :show do |c|
@@ -1465,13 +1571,13 @@ command :show do |c|
   c.example 'doing show Ideas @doing --from "mon to fri"', desc: 'Show entries tagged @doing from the Ideas section added between monday and friday of the current week.'
   c.example 'doing show --interactive Later @doing', desc: 'Create a menu from entries from the Later section tagged @doing to perform batch actions'
 
-  c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.desc 'Tag filter, combine multiple tags with a comma. Use `--tag pick` for a menu of available tags. Wildcards allowed (*, ?). Added for compatibility with other commands.'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean (AND,OR,NOT)'
+  c.desc 'Tag boolean (AND,OR,NOT). Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'OR'
+  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Max count to show'
   c.arg_name 'MAX'
@@ -1481,14 +1587,26 @@ command :show do |c|
   c.arg_name 'AGE'
   c.flag %i[a age], default_value: 'newest'
 
-  c.desc 'View entries older than date'
+  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.desc 'View entries newer than date'
+  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.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing show --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Search filter, surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
   c.flag [:search]
@@ -1510,17 +1628,12 @@ command :show do |c|
   c.arg_name 'ORDER'
   c.flag %i[s sort], must_match: REGEX_SORT_ORDER, default_value: 'asc'
 
-  c.desc %(
-    Date range to show, or a single day to filter date on.
-    Date range argument should be quoted. Date specifications can be natural language.
-    To specify a range, use "to" or "through": `doing show --from "monday to friday"`
-  )
-  c.arg_name 'DATE_OR_RANGE'
-  c.flag %i[f from]
-
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1537,6 +1650,9 @@ command :show do |c|
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
+  c.desc 'Select section or tag to display from a menu'
+  c.switch %i[m menu], negatable: false, default_value: false
+
   c.desc 'Select from a menu of matching entries to perform additional operations'
   c.switch %i[i interactive], negatable: false, default_value: false
 
@@ -1549,15 +1665,17 @@ command :show do |c|
 
     tag_filter = false
     tags = []
+
     if args.length.positive?
       case args[0]
       when /^all$/i
         section = 'All'
         args.shift
       when /^(choose|pick)$/i
-        section = wwid.choose_section
+        section = wwid.choose_section(include_all: true)
+
         args.shift
-      when /^@/
+      when /^[@+-]/
         section = 'All'
       else
         begin
@@ -1580,7 +1698,14 @@ command :show do |c|
         end
       end
     else
-      section = settings['current_section']
+      section = options[:menu] ? wwid.choose_section(include_all: true) : settings['current_section']
+    end
+
+    if options[:menu]
+      tag = wwid.choose_tag(section, include_all: true)
+      raise UserCancelled unless tag
+
+      tags.concat(tag.split(/ +/).map { |t| t.strip.sub(/^@/, '') }) if tag =~ /^@/
     end
 
     tags.concat(options[:tag].to_tags) if options[:tag]
@@ -1592,21 +1717,6 @@ command :show 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 = wwid.chronify(dates[0], guess: :begin)
-        finish = wwid.chronify(dates[2], guess: :end)
-      else
-        start = wwid.chronify(date_string, guess: :begin)
-        finish = false
-      end
-      raise InvalidTimeExpression, 'Unrecognized date string' unless start
-      dates = [start, finish]
-    end
-
     options[:times] = true if options[:totals]
 
     template = settings['templates']['default'].deep_merge({
@@ -1627,7 +1737,6 @@ command :show do |c|
     opt = options.dup
     opt[:sort_tags] = options[:tag_sort] =~ /^n/i
     opt[:count] = options[:count].to_i
-    opt[:date_filter] = dates
     opt[:highlight] = true
     opt[:order] = options[:sort].normalize_order
     opt[:section] = section
@@ -1641,11 +1750,11 @@ command :show do |c|
 end
 
 desc 'Search for entries'
-long_desc <<~'EODESC'
-  Search all sections (or limit to a single section) for entries matching text or regular expression. Normal strings are fuzzy matched.
+long_desc %(
+Search all sections (or limit to a single section) for entries matching text or regular expression. Normal strings are fuzzy matched.
 
-  To search with regular expressions, single quote the string and surround with slashes: `doing search '/\bm.*?x\b/'`
-EODESC
+To search with regular expressions, single quote the string and surround with slashes: `doing search '/\bm.*?x\b/'`
+)
 
 arg_name 'SEARCH_PATTERN'
 command %i[grep search] do |c|
@@ -1658,14 +1767,25 @@ command %i[grep search] do |c|
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Constrain search to entries older than date'
+  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.desc 'Constrain search to entries newer than date'
+  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.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing search --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
   c.flag %i[o output]
@@ -1673,6 +1793,9 @@ command %i[grep search] do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1742,6 +1865,9 @@ command :recent do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1781,7 +1907,8 @@ command :recent do |c|
         tags_color: tags_color,
         times: options[:times],
         totals: options[:totals],
-        interactive: options[:interactive]
+        interactive: options[:interactive],
+        duration: options[:duration]
       }
 
       Doing::Pager::page wwid.recent(count, section.cap_first, opts)
@@ -1791,6 +1918,8 @@ command :recent do |c|
 end
 
 desc 'List entries from today'
+long_desc 'List entries from the current day. Use --before, --after, and
+--from to specify time ranges.'
 command :today do |c|
   c.example 'doing today', desc: 'List all entries with start dates between 12am and 11:59PM for the current day'
   c.example 'doing today --section Later', desc: 'List today\'s entries in the Later section'
@@ -1804,6 +1933,9 @@ command :today do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1825,19 +1957,20 @@ command :today do |c|
   c.arg_name 'TIME_STRING'
   c.flag [:after]
 
+  c.desc %(
+    Time range to show `doing today --from "12pm to 4pm"`
+  )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   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
-    opt = {
-      after: options[:after],
-      before: options[:before],
-      section: options[:section],
-      sort_tags: options[:sort_tags],
-      totals: options[:totals]
-    }
-    Doing::Pager.page wwid.today(options[:times], options[:output], opt).chomp
+    filter_options = %i[after before duration from section sort_tags totals].each_with_object({}) { |k, hsh| hsh[k] = options[k] }
+
+    Doing::Pager.page wwid.today(options[:times], options[:output], filter_options).chomp
   end
 end
 
@@ -1858,6 +1991,9 @@ command :on do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1880,10 +2016,10 @@ command :on do |c|
 
     if date_string =~ / (to|through|thru) /
       dates = date_string.split(/ (to|through|thru) /)
-      start = wwid.chronify(dates[0], guess: :begin)
-      finish = wwid.chronify(dates[2], guess: :end)
+      start = dates[0].chronify(guess: :begin)
+      finish = dates[2].chronify(guess: :end)
     else
-      start = wwid.chronify(date_string, guess: :begin)
+      start = date_string.chronify(guess: :begin)
       finish = false
     end
 
@@ -1897,7 +2033,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],
-                        { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+                        { duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
@@ -1916,6 +2052,9 @@ command :since do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1939,7 +2078,7 @@ command :since do |c|
     date_string.sub!(/(day) (\d)/, '\1 at \2')
     date_string.sub!(/(\d+)d( ago)?/, '\1 days ago')
 
-    start = wwid.chronify(date_string, guess: :begin)
+    start = date_string.chronify(guess: :begin)
     finish = Time.now
 
     raise InvalidTimeExpression, 'Unrecognized date string' unless start
@@ -1950,11 +2089,13 @@ 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],
-                        { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+                        { duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
 desc 'List entries from yesterday'
+desc 'Show only entries with start times within the previous 24 hour period. Use --before, --after, and --from to limit to
+time spans within the day.'
 command :yesterday do |c|
   c.example 'doing yesterday', desc: 'List all entries from the previous day'
   c.example 'doing yesterday --after 8am --before 5pm', desc: 'List entries from the previous day between 8am and 5pm'
@@ -1971,6 +2112,9 @@ command :yesterday do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
@@ -1987,6 +2131,12 @@ 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.arg_name 'TIME_RANGE'
+  c.flag [:from]
+
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
   c.flag [:tag_order], must_match: REGEX_SORT_ORDER, default_value: 'asc'
@@ -1996,9 +2146,17 @@ 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|
+        "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],
@@ -2009,6 +2167,8 @@ command :yesterday do |c|
 end
 
 desc 'Show the last entry, optionally edit'
+long_desc 'Shows the last entry. Using --search and --tag filters, you can view/edit the last entry matching a filter,
+allowing `doing last` to target historical entries.'
 command :last do |c|
   c.example 'doing last', desc: 'Show the most recent entry in all sections'
   c.example 'doing last -s Later', desc: 'Show the most recent entry in the Later section'
@@ -2025,18 +2185,21 @@ command :last do |c|
   c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
-  c.desc 'Tag filter, combine multiple tags with a comma.'
+  c.desc 'Tag filter, combine multiple tags with a comma. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean'
+  c.desc 'Tag boolean (AND|OR|NOT). Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Search filter, surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
   c.flag [:search]
 
+  c.desc 'Show elapsed time if entry is not tagged @done'
+  c.switch [:duration]
+
   # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
   # c.switch [:fuzzy], default_value: false, negatable: false
 
@@ -2059,6 +2222,8 @@ command :last do |c|
     else
       tags = options[:tag].to_tags
       options[:bool] = case options[:bool]
+                       when /^p/i
+                        :pattern
                        when /(any|or)/i
                         :or
                        when /(not|none)/i
@@ -2082,7 +2247,15 @@ command :last do |c|
       wwid.edit_last(section: options[:section], options: { search: search, fuzzy: options[:fuzzy], case: options[:case], tag: tags, tag_bool: options[:bool], not: options[:not] })
     else
       Doing::Pager::page wwid.last(times: true, section: options[:section],
-                     options: { search: search, fuzzy: options[:fuzzy], case: options[:case], negate: options[:not], tag: tags, tag_bool: options[:bool] }).strip
+                     options: {
+                        duration: options[:duration],
+                        search: search,
+                        fuzzy: options[:fuzzy],
+                        case: options[:case],
+                        negate: options[:not],
+                        tag: tags,
+                        tag_bool: options[:bool]
+                      }).strip
     end
   end
 end
@@ -2163,6 +2336,8 @@ command :plugins do |c|
 end
 
 desc 'Generate shell completion scripts'
+desc 'Generates the necessary scripts to add command line completion to various shells, so typing \'doing\' and hitting
+tab will offer completions of subcommands and their options.'
 command :completion do |c|
   c.example 'doing completion', desc: 'Output zsh (default) to STDOUT'
   c.example 'doing completion --type zsh --file ~/.zsh-completions/_doing.zsh', desc: 'Output zsh completions to file'
@@ -2185,7 +2360,8 @@ command :completion do |c|
 end
 
 desc 'Display a user-created view'
-long_desc 'Command line options override view configuration'
+long_desc 'Views are defined in your configuration (use `doing config` to edit).
+Command line options override view configuration.'
 arg_name 'VIEW_NAME'
 command :view do |c|
   c.example 'doing view color', desc: 'Display entries according to config for view "color"'
@@ -2206,19 +2382,22 @@ command :view do |c|
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: false
 
   c.desc 'Include colors in output'
   c.switch [:color], default_value: true, negatable: true
 
-  c.desc 'Tag filter, combine multiple tags with a comma.'
+  c.desc 'Tag filter, combine multiple tags with a comma. Wildcards allowed (*, ?).'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean (AND,OR,NOT)'
+  c.desc 'Tag boolean (AND,OR,NOT). Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'OR'
+  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Search filter, surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
@@ -2245,14 +2424,25 @@ command :view do |c|
   c.arg_name 'DIRECTION'
   c.flag [:tag_order], must_match: REGEX_SORT_ORDER
 
-  c.desc 'View entries older than date'
+  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.desc 'View entries newer than date'
+  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.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing view --from "monday 8am to friday 5pm" view_name`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Only show items with recorded time intervals (override view settings)'
   c.switch [:only_timed], default_value: false, negatable: false
 
@@ -2301,16 +2491,22 @@ command :view do |c|
       tag_filter = false
       if options[:tag]
         tag_filter = { 'tags' => [], 'bool' => 'OR' }
-        tag_filter['tags'] = options[:tag].gsub(/[, ]+/, ' ').split(' ').map(&:strip)
-        tag_filter['bool'] = options[:bool].normalize_bool
+        bool = options[:bool].normalize_bool
+        tag_filter['bool'] = bool
+        tag_filter['tags'] = if bool == :pattern
+                               options[:tag]
+                             else
+                               options[:tag].gsub(/[, ]+/, ' ').split(' ').map(&:strip)
+                             end
       elsif view.key?('tags') && !(view['tags'].nil? || view['tags'].empty?)
         tag_filter = { 'tags' => [], 'bool' => 'OR' }
+        bool = view.key?('tags_bool') && !view['tags_bool'].nil? ? view['tags_bool'].normalize_bool : :pattern
+        tag_filter['bool'] = bool
         tag_filter['tags'] = if view['tags'].instance_of?(Array)
-                               view['tags'].map(&:strip)
+                               bool == :pattern ? view['tags'].join(' ').strip : view['tags'].map(&:strip)
                              else
-                               view['tags'].gsub(/[, ]+/, ' ').split(' ').map(&:strip)
+                               bool == :pattern ? view['tags'].strip : view['tags'].gsub(/[, ]+/, ' ').split(' ').map(&:strip)
                              end
-        tag_filter['bool'] = view.key?('tags_bool') && !view['tags_bool'].nil? ? view['tags_bool'].normalize_bool : :or
       end
 
       # If the -o/--output flag was specified, override any default in the view template
@@ -2346,27 +2542,8 @@ command :view do |c|
                             else
                               false
                             end
-      if view.key?('after') && !options[:after]
-        options[:after] = view['after']
-      end
 
-      if view.key?('before') && !options[:before]
-        options[:before] = view['before']
-      end
-
-      if view.key?('from')
-        date_string = view['from']
-        if date_string =~ / (to|through|thru|(un)?til|-+) /
-          dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-          start = wwid.chronify(dates[0], guess: :begin)
-          finish = wwid.chronify(dates[2], guess: :end)
-        else
-          start = wwid.chronify(date_string, guess: :begin)
-          finish = false
-        end
-        raise InvalidTimeExpression, 'Unrecognized date string' unless start
-        dates = [start, finish]
-      end
+      %w[before after from duration].each { |k| options[k.to_sym] = view[k] if view.key?(k) && !options[k.to_sym] }
 
       options[:case] = options[:case].normalize_case
 
@@ -2378,22 +2555,21 @@ command :view do |c|
       end
 
       opts = options.dup
-      opts[:search] = search
-      opts[:output] = output_format
       opts[:count] = count
       opts[:format] = date_format
       opts[:highlight] = options[:color]
       opts[:only_timed] = only_timed
       opts[:order] = order
+      opts[:output] = options[:interactive] ? nil : options[:output]
+      opts[:output] = output_format
+      opts[:page_title] = page_title
+      opts[:search] = search
       opts[:section] = section
       opts[:tag_filter] = tag_filter
       opts[:tag_order] = tag_order
       opts[:tags_color] = tags_color
       opts[:template] = template
       opts[:totals] = totals
-      opts[:page_title] = page_title
-      opts[:date_filter] = dates
-      opts[:output] = options[:interactive] ? nil : options[:output]
 
       Doing::Pager.page wwid.list_section(opts)
     elsif title.instance_of?(FalseClass)
@@ -2439,13 +2615,13 @@ command %i[archive move] do |c|
   c.desc 'Label moved items with @from(SECTION_NAME)'
   c.switch [:label], default_value: true, negatable: true
 
-  c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.desc 'Tag filter, combine multiple tags with a comma. Wildcards allowed (*, ?). Added for compatibility with other commands.'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean (AND|OR|NOT)'
+  c.desc 'Tag boolean (AND|OR|NOT). Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Search filter'
   c.arg_name 'QUERY'
@@ -2508,6 +2684,9 @@ command %i[archive move] do |c|
 end
 
 desc 'Move entries to archive file'
+long_desc 'As your doing file grows, commands can get slow. Given that your historical data (and your archive section)
+probably aren\'t providing any useful insights a year later, use this command to "rotate" old entries out to an archive
+file. You\'ll still have access to all historical data, but it won\'t be slowing down daily operation.'
 command :rotate do |c|
   c.example 'doing rotate', desc: 'Move all entries in doing file to a dated secondary file'
   c.example 'doing rotate --section Archive --keep 10', desc: 'Move entries in the Archive section to a secondary file, keeping the most recent 10 entries'
@@ -2521,13 +2700,13 @@ command :rotate do |c|
   c.arg_name 'SECTION_NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.desc 'Tag filter, combine multiple tags with a comma. Wildcards allowed (*, ?). Added for compatibility with other commands.'
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean (AND|OR|NOT)'
+  c.desc 'Tag boolean (AND|OR|NOT). Use PATTERN to parse + and - as booleans.'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
 
   c.desc 'Search filter'
   c.arg_name 'QUERY'
@@ -2574,8 +2753,10 @@ command :rotate do |c|
 end
 
 desc 'Open the "doing" file in an editor'
-long_desc "`doing open` defaults to using the editor_app setting in #{config.config_file} (#{settings.key?('editor_app') ? settings['editor_app'] : 'not set'})."
+long_desc "`doing open` defaults to using the editors->doing_file setting
+in #{config.config_file} (#{Doing::Util.find_default_editor('doing_file')})."
 command :open do |c|
+  c.example 'doing open', desc: 'Open the doing file in the default editor'
   c.desc 'Open with editor command (e.g. vim, mate)'
   c.arg_name 'COMMAND'
   c.flag %i[e editor]
@@ -2597,7 +2778,7 @@ command :open do |c|
     end
 
     if options[:editor]
-      raise MissingEditor, "Editor #{options[:editor]} not found" unless Doing::Util.exec_available(options[:editor])
+      raise MissingEditor, "Editor #{options[:editor]} not found" unless Doing::Util.exec_available(options[:editor].split(/ /).first)
 
       editor = TTY::Which.which(options[:editor])
       system %(#{editor} "#{File.expand_path(wwid.doing_file)}")
@@ -2608,7 +2789,7 @@ command :open do |c|
         system %(open -b "#{options[:bundle_id]}" "#{File.expand_path(wwid.doing_file)}")
       elsif Doing::Util.find_default_editor('doing_file')
         editor = Doing::Util.find_default_editor('doing_file')
-        if Doing::Util.exec_available(editor)
+        if Doing::Util.exec_available(editor.split(/ /).first)
           system %(#{editor} "#{File.expand_path(wwid.doing_file)}")
         else
           system %(open -a "#{editor}" "#{File.expand_path(wwid.doing_file)}")
@@ -2703,7 +2884,7 @@ command :config do |c|
         if options[:default]
           editor = Doing::Util.find_default_editor('config')
           if editor
-            if Doing::Util.exec_available(editor)
+            if Doing::Util.exec_available(editor.split(/ /).first)
               system %(#{editor} "#{config_file}")
             else
               `open -a "#{editor}" "#{config_file}"`
@@ -2722,7 +2903,7 @@ command :config do |c|
 
           raise MissingEditor, 'No viable editor defined in config or environment' unless editor
 
-          if Doing::Util.exec_available(editor)
+          if Doing::Util.exec_available(editor.split(/ /).first)
             system %(#{editor} "#{config_file}")
           else
             `open -a "#{editor}" "#{config_file}"`
@@ -2730,7 +2911,7 @@ command :config do |c|
         end
       else
         editor = options[:editor] || Doing::Util.default_editor
-        raise MissingEditor, 'No EDITOR variable defined in environment' unless editor && Doing::Util.exec_available(editor)
+        raise MissingEditor, 'No EDITOR variable defined in environment' unless editor && Doing::Util.exec_available(editor.split(/ /).first)
 
         system %(#{editor} "#{config_file}")
       end
@@ -2821,9 +3002,21 @@ command :config do |c|
 
       value = options[:remove] ? nil : args.pop
       keypath = args.join('.')
-      old_value = config.value_for_key(keypath).map { |k, v| v.to_s }
-      real_path = config.resolve_key_path(keypath)
-      raise InvalidArgument, 'Invalid key path' if real_path.empty?
+      real_path = config.resolve_key_path(keypath, create: true)
+
+      old_value = settings.dig(*real_path) || nil
+      old_type = old_value&.class.to_s || nil
+
+      if old_value.is_a?(Hash) && !options[:remove]
+        Doing.logger.log_now(:warn, 'Config:', "Config key must point to a single value, #{real_path.join('->').boldwhite} is a mapping")
+        didyou = 'Did you mean:'
+        old_value.keys.each do |k|
+          Doing.logger.log_now(:warn, "#{didyou}", "#{keypath}.#{k}?")
+          didyou = '..........or:'
+        end
+        raise InvalidArgument, 'Config value is a mapping, can not be set to a single value'
+
+      end
 
       config_file = config.choose_config
       cfg = YAML.safe_load_file(config_file) || {}
@@ -2834,11 +3027,11 @@ command :config do |c|
         cfg.deep_set(real_path, nil)
         $stderr.puts "#{'Deleting key:'.yellow} #{real_path.join('->').boldwhite}"
       else
-        old_value = cfg.dig(*real_path) || 'empty'
-        cfg.deep_set(real_path, value.set_type)
+        cfg.deep_set(real_path, value.set_type(old_type))
+
         $stderr.puts "#{'Key path:'.yellow} #{real_path.join('->').boldwhite}"
-        $stderr.puts "#{'Previous:'.yellow} #{old_value.to_s.boldwhite}"
-        $stderr.puts "#{'     New:'.yellow} #{value.set_type.to_s.boldwhite}"
+        $stderr.puts "#{'Previous:'.yellow} #{(old_value ? old_value.to_s : 'empty').boldwhite}"
+        $stderr.puts "#{'     New:'.yellow} #{value.set_type(old_type).to_s.boldwhite}"
       end
 
       res = Doing::Prompt.yn('Update selected config', default_response: true)
@@ -2851,15 +3044,79 @@ command :config do |c|
   end
 end
 
-desc 'Undo the last change to the Doing file'
+desc 'Undo the last X changes to the Doing file'
+long_desc 'Reverts the last X commands that altered the doing file.
+All changes performed by a single command are undone at once.
+
+Specify a number to jump back multiple revisions, or use --select for an interactive menu.'
+arg_name 'COUNT'
 command :undo do |c|
+  c.example 'doing undo', desc: 'Undo the most recent change to the doing file'
+  c.example 'doing undo 5', desc: 'Undo the last 5 changes to the doing file'
+  c.example 'doing undo --interactive', desc: 'Select from a menu of available revisions'
+  c.example 'doing undo --redo', desc: 'Undo the last undo command'
+
   c.desc 'Specify alternate doing file'
   c.arg_name 'PATH'
   c.flag %i[f file], default_value: wwid.doing_file
 
-  c.action do |_global_options, options, _args|
+  c.desc 'Select from recent backups'
+  c.switch %i[i interactive], negatable: false
+
+  c.desc 'Remove old backups, retaining X files'
+  c.arg_name 'COUNT'
+  c.flag %i[p prune], type: Integer
+
+  c.desc 'Redo last undo. Note: you cannot undo a redo.'
+  c.switch %i[r redo]
+
+  c.action do |_global_options, options, args|
+    file = options[:file] || wwid.doing_file
+    count = args.empty? ? 1 : args[0].to_i
+    raise InvalidArgument, "Invalid count specified for undo" unless count&.positive?
+
+    if options[:prune]
+      Doing::Util::Backup.prune_backups(file, options[:prune])
+    elsif options[:redo]
+      Doing::Util::Backup.redo_backup(file, count: count)
+    else
+      if options[:interactive]
+        Doing::Util::Backup.select_backup(file)
+      else
+        Doing::Util::Backup.restore_last_backup(file, count: count)
+      end
+    end
+  end
+end
+
+long_desc 'Shortcut for `doing undo -r`, reverses the last undo command. You cannot undo a redo.'
+arg_name 'COUNT'
+command :redo do |c|
+  c.desc 'Specify alternate doing file'
+  c.arg_name 'PATH'
+  c.flag %i[f file], default_value: wwid.doing_file
+
+  c.action do |_global, options, args|
     file = options[:file] || wwid.doing_file
-    wwid.restore_backup(file)
+    count = args.empty? ? 1 : args[0].to_i
+    raise InvalidArgument, "Invalid count specified for redo" unless count&.positive?
+
+    Doing::Util::Backup.redo_backup(file, count: count)
+  end
+end
+
+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|
+  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
   end
 end
 
@@ -2867,6 +3124,10 @@ desc 'Import entries from an external source'
 long_desc "Imports entries from other sources. Available plugins: #{Doing::Plugins.plugin_names(type: :import, separator: ', ')}"
 arg_name 'PATH'
 command :import do |c|
+  c.example 'doing import --type timing "~/Desktop/All Activities.json"', desc: 'Import a Timing.app JSON report'
+  c.example 'doing import --type doing --tag imported --no-autotag ~/doing_backup.md', desc: 'Import an Doing archive, tag all entries with @imported, skip autotagging'
+  c.example 'doing import --type doing --from "10/1 to 10/15" ~/doing_backup.md', desc: 'Import a Doing archive, only importing entries between two dates'
+
   c.desc "Import type (#{Doing::Plugins.plugin_names(type: :import)})"
   c.arg_name 'TYPE'
   c.flag :type, default_value: 'doing'
@@ -2906,6 +3167,7 @@ command :import do |c|
   c.arg_name 'PREFIX'
   c.flag :prefix
 
+  # TODO: Allow time range filtering
   c.desc 'Import entries older than date'
   c.arg_name 'DATE_STRING'
   c.flag [:before]
@@ -2935,10 +3197,10 @@ command :import do |c|
       date_string = options[:from]
       if date_string =~ / (to|through|thru|(un)?til|-+) /
         dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-        start = wwid.chronify(dates[0], guess: :begin)
-        finish = wwid.chronify(dates[2], guess: :end)
+        start = dates[0].chronify(guess: :begin)
+        finish = dates[2].chronify(guess: :end)
       else
-        start = wwid.chronify(date_string, guess: :begin)
+        start = date_string.chronify(guess: :begin)
         finish = false
       end
       raise InvalidTimeExpression, 'Unrecognized date string' unless start
@@ -3005,10 +3267,13 @@ around do |global, command, options, arguments, code|
 
   if global[:yes]
     Doing::Prompt.force_answer = true
+    Doing.config.force_answer = true
   elsif global[:no]
     Doing::Prompt.force_answer = false
+    Doing.config.force_answer = false
   else
     Doing::Prompt.default_answer = global[:default]
+    Doing.config.force_answer = global[:default] ? true : false
   end
 
   if global[:config_file] && global[:config_file] != config.config_file