doing 2.1.2pre → 2.1.6pre

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)
@@ -51,11 +51,16 @@ if ENV['DOING_LOG_LEVEL'] || ENV['DOING_DEBUG'] || ENV['DOING_QUIET'] || ENV['DO
   end
 end
 
+Doing.logger.benchmark(:total, :start)
+
 if ENV['DOING_CONFIG']
   Doing.config_with(ENV['DOING_CONFIG'], { ignore_local: true })
 end
 
+Doing.logger.benchmark(:configure, :start)
 config = Doing.config
+Doing.logger.benchmark(:configure, :finish)
+
 settings = config.settings
 wwid.config = settings
 
@@ -195,7 +200,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 +217,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]
 
@@ -215,23 +229,30 @@ command %i[reset begin] do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Reset items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   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 +280,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 +288,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 +322,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]
 
@@ -313,18 +334,18 @@ command :note do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Add note to item that *doesn\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
-  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 +415,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'
@@ -483,6 +508,13 @@ command :template do |c|
   c.desc 'List in single column for completion'
   c.switch %i[c column]
 
+  c.desc 'Save template to file instead of STDOUT'
+  c.switch %i[s save], default_value: false, negatable: false
+
+  c.desc 'Save template to alternate location'
+  c.arg_name 'DIRECTORY'
+  c.flag %i[p path], default_value: File.join(Doing::Util.user_home, '.config', 'doing', 'templates')
+
   c.action do |_global_options, options, args|
     if options[:list] || options[:column]
       if options[:column]
@@ -495,13 +527,19 @@ command :template do |c|
 
     if args.empty?
       type = Doing::Prompt.choose_from(Doing::Plugins.plugin_templates, sorted: false, prompt: 'Select template type > ')
+      type.sub!(/ \(.*?\)$/, '').strip!
+      options[:save] = Doing::Prompt.yn("Save to #{options[:path]}? (No outputs to STDOUT)", default_response: false)
     else
       type = args[0]
     end
 
     raise InvalidPluginType, "No type specified, use `doing template [#{Doing::Plugins.plugin_templates.join('|')}]`" unless type
 
-    $stdout.puts Doing::Plugins.template_for_trigger(type)
+    if options[:save]
+      Doing::Plugins.template_for_trigger(type, save_to: options[:path])
+    else
+      $stdout.puts Doing::Plugins.template_for_trigger(type, save_to: nil)
+    end
 
     # case args[0]
     # when /html|haml/i
@@ -521,8 +559,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]
@@ -568,14 +617,14 @@ command :select do |c|
   c.flag [:from]
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Select items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Use --no-menu to skip the interactive menu. Use with --query to filter items and act on results automatically. Test with `--output doing` to preview matches.'
   c.switch %i[menu], negatable: true, default_value: true
@@ -680,6 +729,9 @@ command :later do |c|
 end
 
 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'
 command %i[done did] do |c|
   c.example 'doing done', desc: 'Tag the last entry @done'
@@ -890,13 +942,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'
@@ -906,14 +958,14 @@ command :cancel do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Finish items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Cancel last entry (or entries) not already marked @done'
   c.switch %i[u unfinished], negatable: false, default_value: false
@@ -997,7 +1049,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]
 
@@ -1009,18 +1061,18 @@ command :finish do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Finish items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
-  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
@@ -1119,7 +1171,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'
@@ -1128,7 +1187,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]
 
@@ -1141,18 +1200,18 @@ command %i[again resume] do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Resume items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
-  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
@@ -1186,6 +1245,77 @@ 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.desc 'Get tags for entries matching tags. Combine multiple tags with a comma. Wildcards allowed (*, ?).'
+  c.arg_name 'TAG'
+  c.flag [:tag]
+
+  c.desc 'Get tags for items matching search. Surround with
+  slashes for regex (e.g. "/query/"), start with a single quote for exact match ("\'query").'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
+  # c.switch [:fuzzy], default_value: false, negatable: false
+
+  c.desc 'Force exact search string matching (case sensitive)'
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
+
+  c.desc 'Get tags from items that *don\'t* match search/tag filters'
+  c.switch [:not], default_value: false, negatable: false
+
+  c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
+  c.arg_name 'TYPE'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
+
+  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: 'PATTERN'
+
+  c.desc 'Select items to scan from a menu of matching entries'
+  c.switch %i[i interactive], negatable: false, default_value: false
+
+  c.action do |_global, options, args|
+    section = wwid.guess_section(options[:section]) || options[:section].cap_first
+
+    items = wwid.filter_items([], opt: options)
+
+    # 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
@@ -1239,7 +1369,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]
 
@@ -1251,18 +1381,18 @@ command :tag do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Tag items that *don\'t* match search/tag filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
-  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
@@ -1314,44 +1444,49 @@ command :tag do |c|
       options[:search] = search
     end
 
+    options[:count] = count
+    options[:section] = section
+    options[:tag] = search_tags
+    options[:tags] = tags
+    options[:tag_bool] = options[:bool].normalize_bool
+
     if count.zero? && !options[:force]
-      if options[:search]
-        section_q = ' matching your search terms'
-      elsif options[:tag]
-        section_q = ' matching your tag search'
-      elsif section == 'All'
-        section_q = ''
-      else
-        section_q = " in section #{section}"
-      end
+      matches = wwid.filter_items([], opt: options).count
+
+      if matches > 5
+        if options[:search]
+          section_q = ' matching your search terms'
+        elsif options[:tag]
+          section_q = ' matching your tag search'
+        elsif section == 'All'
+          section_q = ''
+        else
+          section_q = " in section #{section}"
+        end
 
 
-      question = if options[:aarchive]
-                   "Are you sure you want to autotag all records#{section_q}"
-                 elsif options[:remove]
-                   "Are you sure you want to remove #{tags.join(' and ')} from all records#{section_q}"
-                 else
-                   "Are you sure you want to add #{tags.join(' and ')} to all records#{section_q}"
-                 end
+        question = if options[:autotag]
+                     "Are you sure you want to autotag #{matches} records#{section_q}"
+                   elsif options[:remove]
+                     "Are you sure you want to remove #{tags.join(' and ')} from #{matches} records#{section_q}"
+                   else
+                     "Are you sure you want to add #{tags.join(' and ')} to #{matches} records#{section_q}"
+                   end
 
-      res = Doing::Prompt.yn(question, default_response: false)
+        res = Doing::Prompt.yn(question, default_response: false)
 
-      raise UserCancelled unless res
+        raise UserCancelled unless res
+      end
     end
 
-    options[:count] = count
-    options[:section] = section
-    options[:tag] = search_tags
-    options[:tags] = tags
-    options[:tag_bool] = options[:bool].normalize_bool
-
     wwid.tag_last(options)
   end
 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'
 
@@ -1376,7 +1511,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]
 
@@ -1388,18 +1523,18 @@ command [:mark, :flag] do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Flag items that *don\'t* match search/tag/date filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
-  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
@@ -1473,7 +1608,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|
@@ -1485,17 +1624,17 @@ 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'
-  c.flag %i[c count], default_value: 0
+  c.flag %i[c count], default_value: 0, must_match: /^\d+$/, type: Integer
 
   c.desc 'Age (oldest|newest)'
   c.arg_name 'AGE'
@@ -1529,14 +1668,14 @@ command :show do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Show items that *don\'t* match search/tag/date filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Sort order (asc/desc)'
   c.arg_name 'ORDER'
@@ -1564,6 +1703,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
 
@@ -1576,15 +1718,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
@@ -1607,18 +1751,12 @@ command :show do |c|
         end
       end
     else
-      section = settings['current_section']
+      section = options[:menu] ? wwid.choose_section(include_all: true) : settings['current_section']
+      section ||= 'All'
     end
 
     tags.concat(options[:tag].to_tags) if options[:tag]
 
-    unless tags.empty?
-      tag_filter = {
-        'tags' => tags,
-        'bool' => options[:bool].normalize_bool
-      }
-    end
-
     options[:times] = true if options[:totals]
 
     template = settings['templates']['default'].deep_merge({
@@ -1636,27 +1774,55 @@ command :show do |c|
       options[:search] = search
     end
 
+    options[:section] = section
+
+    unless tags.empty?
+      tag_filter = {
+        'tags' => tags,
+        'bool' => options[:bool].normalize_bool
+      }
+    end
+
+    options[:tag_filter] = tag_filter
+    options[:tag] = nil
+
+    items = wwid.filter_items([], opt: options)
+
+    if options[:menu]
+      tag = wwid.choose_tag(section, items: items, include_all: true)
+      raise UserCancelled unless tag
+
+      # options[:bool] = :and unless tags.empty?
+
+      tags = tag.split(/ +/).map { |t| t.strip.sub(/^@?/, '') } if tag =~ /^@/
+      unless tags.empty?
+        tag_filter = {
+          'tags' => tags,
+          'bool' => options[:bool].normalize_bool
+        }
+        options[:tag_filter] = tag_filter
+      end
+    end
+
     opt = options.dup
     opt[:sort_tags] = options[:tag_sort] =~ /^n/i
     opt[:count] = options[:count].to_i
     opt[:highlight] = true
     opt[:order] = options[:sort].normalize_order
-    opt[:section] = section
     opt[:tag] = nil
-    opt[:tag_filter] = tag_filter
     opt[:tag_order] = options[:tag_order].normalize_order
     opt[:tags_color] = template['tags_color']
 
-    Doing::Pager.page wwid.list_section(opt)
+    Doing::Pager.page wwid.list_section(opt, items: items)
   end
 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|
@@ -1714,14 +1880,14 @@ command %i[grep search] do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Show items that *don\'t* match search string'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Display an interactive menu of results to perform further operations'
   c.switch %i[i interactive], default_value: false, negatable: false
@@ -1820,6 +1986,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'
@@ -1994,6 +2162,8 @@ command :since do |c|
 end
 
 desc 'List entries from yesterday'
+long_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'
@@ -2065,6 +2235,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'
@@ -2081,13 +2253,13 @@ 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'
@@ -2100,14 +2272,14 @@ command :last do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Show items that *don\'t* match search string or tag filter'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.action do |global_options, options, _args|
     options[:fuzzy] = false
@@ -2117,15 +2289,7 @@ command :last do |c|
       tags = []
     else
       tags = options[:tag].to_tags
-      options[:bool] = case options[:bool]
-                       when /(any|or)/i
-                        :or
-                       when /(not|none)/i
-                        :not
-                       else
-                        :and
-                       end
-
+      options[:bool] = options[:bool].normalize_bool
     end
 
     options[:case] = options[:case].normalize_case
@@ -2230,6 +2394,8 @@ command :plugins do |c|
 end
 
 desc 'Generate shell completion scripts'
+long_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'
@@ -2252,7 +2418,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"'
@@ -2282,13 +2449,13 @@ command :view do |c|
   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'
@@ -2298,14 +2465,14 @@ command :view do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Show items that *don\'t* match search string'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Sort tags by (name|time)'
   c.arg_name 'KEY'
@@ -2367,6 +2534,7 @@ command :view do |c|
     end
 
     view = wwid.get_view(title)
+
     if view
       page_title = view.key?('title') ? view['title'] : title.cap_first
       only_timed = if (view.key?('only_timed') && view['only_timed']) || options[:only_timed]
@@ -2382,16 +2550,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
@@ -2440,6 +2614,7 @@ command :view do |c|
       end
 
       opts = options.dup
+      opts[:view_template] = title
       opts[:count] = count
       opts[:format] = date_format
       opts[:highlight] = options[:color]
@@ -2500,13 +2675,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'
@@ -2516,14 +2691,14 @@ command %i[archive move] do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Show items that *don\'t* match search string'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Archive entries older than date
     (Flexible date format, e.g. 1/27/2021, 2020-07-19, or Monday 3pm)'
@@ -2569,6 +2744,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'
@@ -2582,13 +2760,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'
@@ -2598,14 +2776,14 @@ command :rotate do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Rotate items that *don\'t* match search string or tag filter'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Rotate entries older than date
     (Flexible date format, e.g. 1/27/2021, 2020-07-19, or Monday 3pm)'
@@ -2635,8 +2813,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]
@@ -2810,7 +2990,7 @@ command :config do |c|
   c.command :undo do |undo|
     undo.action do |_global, options, args|
       config_file = config.choose_config
-      wwid.restore_backup(config_file)
+      Doing::Util::Backup.restore_last_backup(config_file, count: 1)
     end
   end
 
@@ -2885,6 +3065,7 @@ command :config do |c|
       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")
@@ -2906,13 +3087,11 @@ command :config do |c|
         cfg.deep_set(real_path, nil)
         $stderr.puts "#{'Deleting key:'.yellow} #{real_path.join('->').boldwhite}"
       else
-
-        p real_path
-        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 ? old_value .to_s : 'empty').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)
@@ -2925,22 +3104,126 @@ 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]
+      if options[:interactive]
+        Doing::Util::Backup.select_redo(file)
+      else
+        Doing::Util::Backup.redo_backup(file, count: count)
+      end
+    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.desc 'Select from an interactive menu'
+  c.switch %i[i interactive]
+
+  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?
+    if options[:interactive]
+      Doing::Util::Backup.select_redo(file)
+    else
+      Doing::Util::Backup.redo_backup(file, count: count)
+    end
   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
+
+arg_name 'OPTION'
+command :commands_accepting do |c|
+  c.desc 'Output in single column for completion'
+  c.switch %i[c column]
+
+  c.action do |g, o, a|
+    a.each do |option|
+      cmds = []
+      commands.each do |cmd, v|
+        v.flags.merge(v.switches).each do |n, flag|
+          if flag.name == option.to_sym || flag.aliases&.include?(option.to_sym)
+            cmds.push(cmd)
+          end
+        end
+      end
+
+      if o[:column]
+        puts cmds
+      else
+        puts "Commands accepting --#{option}: #{cmds.join(', ')}"
+      end
+    end
+  end
+end
+
+
 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'
@@ -2953,14 +3236,14 @@ command :import do |c|
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact search string matching (case sensitive)'
-  c.switch %i[x exact], default_value: false, negatable: false
+  c.switch %i[x exact], default_value: config.exact_match?, negatable: config.exact_match?
 
   c.desc 'Import items that *don\'t* match search/tag/date filters'
   c.switch [:not], default_value: false, negatable: false
 
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
-  c.flag [:case], must_match: /^[csi]/, default_value: 'smart'
+  c.flag [:case], must_match: /^[csi]/, default_value: settings.dig('search', 'case')
 
   c.desc 'Only import items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
@@ -3035,7 +3318,6 @@ end
 
 pre do |global, _command, _options, _args|
   # global[:pager] ||= settings['paginate']
-
   Doing::Pager.paginate = global[:pager]
 
   $stdout.puts "doing v#{Doing::VERSION}" if global[:version]
@@ -3066,6 +3348,8 @@ post do |global, _command, _options, _args|
   # Use skips_post before a command to skip this
   # block on that command only
   Doing.logger.output_results
+  Doing.logger.benchmark(:total, :finish)
+  Doing.logger.log_benchmarks
 end
 
 around do |global, command, options, arguments, code|
@@ -3080,10 +3364,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
@@ -3096,13 +3383,13 @@ around do |global, command, options, arguments, code|
     config.config_file = cf
     settings = config.configure({ ignore_local: true })
   end
-
+  Doing.logger.benchmark(:init, :start)
   if global[:doing_file]
     wwid.init_doing_file(global[:doing_file])
   else
     wwid.init_doing_file
   end
-
+  Doing.logger.benchmark(:init, :finish)
   wwid.auto_tag = !global[:noauto]
 
   settings[:include_notes] = false unless global[:notes]