doing 1.0.93 → 2.0.2.pre

data/bin/doing

@@ -20,17 +20,49 @@ if class_exists? 'Encoding'
 end
 
 include GLI::App
+include Doing::Errors
 version Doing::VERSION
+hide_commands_without_desc true
+autocomplete_commands true
+
+REGEX_BOOL = /^(?:and|all|any|or|not|none)$/i
+REGEX_SORT_ORDER = /^(?:a(?:sc)?|d(?:esc)?)$/i
+
+InvalidExportType = Class.new(RuntimeError)
+MissingConfigFile = Class.new(RuntimeError)
+
+colors = Doing::Color
+wwid = Doing::WWID.new
+
+Doing.logger.log_level = :info
+
+if ENV['DOING_LOG_LEVEL'] || ENV['DOING_DEBUG'] || ENV['DOING_QUIET'] || ENV['DOING_VERBOSE'] || ENV['DOING_PLUGIN_DEBUG']
+  # Quiet always wins
+  if ENV['DOING_QUIET'] && ENV['DOING_QUIET'].truthy?
+    Doing.logger.log_level = :error
+  elsif (ENV['DOING_PLUGIN_DEBUG'] && ENV['DOING_PLUGIN_DEBUG'].truthy?)
+    Doing.logger.log_level = :debug
+  elsif (ENV['DOING_DEBUG'] && ENV['DOING_DEBUG'].truthy?)
+    Doing.logger.log_level = :debug
+  elsif ENV['DOING_LOG_LEVEL']
+    Doing.logger.log_level = ENV['DOING_LOG_LEVEL']
+  end
+end
 
-wwid = WWID.new
-wwid.user_home = if Dir.respond_to?('home')
-                   Dir.home
-                 else
-                   File.expand_path('~')
-                 end
-wwid.configure
+if ENV['DOING_CONFIG']
+  Doing.config_with(ENV['DOING_CONFIG'], { ignore_local: true })
+end
+
+config = Doing.config
+settings = config.settings
+wwid.config = settings
+
+if config.settings.dig('plugins', 'command_path')
+  commands_from File.expand_path(config.settings.dig('plugins', 'command_path'))
+end
 
 program_desc 'A CLI for a What Was I Doing system'
+program_long_desc %(Doing uses a TaskPaper-like formatting to keep a plain text record of what you've been doing, complete with tag-based time tracking. The command line tool allows you to add entries, annotate with tags and notes, and view your entries with myriad options, with a focus on a "natural" language syntax.)
 
 default_command :recent
 # sort_help :manually
@@ -41,23 +73,49 @@ switch [:notes], default_value: true, negatable: true
 desc 'Send results report to STDOUT instead of STDERR'
 switch [:stdout], default_value: false, negatable: false
 
+desc 'Use a pager when output is longer than screen'
+switch %i[p pager], default_value: settings['paginate']
+
+desc 'Answer yes/no menus with default option'
+switch [:default], default_value: false
+
 desc 'Exclude auto tags and default tags'
-switch %i[x noauto], default_value: false
+switch %i[x noauto], default_value: false, negatable: false
+
+desc 'Colored output'
+switch %i[color], default_value: true
+
+desc 'Silence info messages'
+switch %i[q quiet], default_value: false, negatable: false
+
+desc 'Verbose output'
+switch %i[debug], default_value: false, negatable: false
 
-desc 'Use a specific configuration file'
-flag [:config_file], default_value: wwid.config_file
+desc 'Use a specific configuration file. Deprecated, set $DOING_CONFIG instead.'
+flag [:config_file], default_value: config.config_file
 
 desc 'Specify a different doing_file'
 flag %i[f doing_file]
 
 desc 'Add an entry'
+long_desc %(Record what you're starting now, or backdate the start time using natural language.
+
+A parenthetical at the end of the entry will be converted to a note.
+
+Run with no argument to create a new entry using #{Doing::Util.default_editor}.)
 arg_name 'ENTRY'
 command %i[now next] do |c|
+  c.example 'doing now', desc: "Open #{Doing::Util.default_editor} to input an entry and optional note."
+  c.example 'doing now working on a new project', desc: 'Add a new entry at the current time'
+  c.example 'doing now debugging @project2', desc: 'Add an entry with a tag'
+  c.example 'doing now adding an entry (with a note)', desc: 'Parenthetical at end is converted to note'
+  c.example 'doing now --back 2pm A thing I started at 2:00 and am still doing...', desc: 'Backdate an entry'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section]
 
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc 'Backdate start time [4pm|20m|2h|yesterday noon]'
@@ -67,7 +125,7 @@ command %i[now next] do |c|
   c.desc 'Timed entry, marks last entry in section as @done'
   c.switch %i[f finish_last], negatable: false, default_value: false
 
-  c.desc 'Note'
+  c.desc 'Include a note'
   c.arg_name 'TEXT'
   c.flag %i[n note]
 
@@ -77,9 +135,9 @@ command %i[now next] do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back])
+      date = wwid.chronify(options[:back], guess: :begin)
 
-      exit_now! 'Unable to parse date string' if date.nil?
+      raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
@@ -87,17 +145,17 @@ command %i[now next] do |c|
     if options[:section]
       section = wwid.guess_section(options[:section]) || options[:section].cap_first
     else
-      options[:section] = wwid.config['current_section']
+      options[:section] = settings['current_section']
     end
 
     if options[:e] || (args.empty? && $stdin.stat.size.zero?)
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       input = ''
       input += args.join(' ') unless args.empty?
       input = wwid.fork_editor(input).strip
 
-      exit_now! 'No content' if input.empty?
+      raise Doing::Errors::EmptyInput, 'No content' if input.empty?
 
       title, note = wwid.format_input(input)
       note.push(options[:n]) if options[:n]
@@ -115,14 +173,76 @@ command %i[now next] do |c|
       wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:f] })
       wwid.write(wwid.doing_file)
     else
-      exit_now! 'You must provide content when creating a new entry'
+      raise Doing::Errors::EmptyInput, 'You must provide content when creating a new entry'
+    end
+  end
+end
+
+desc 'Reset the start time of an entry'
+command %i[reset begin] do |c|
+  c.desc 'Set the start date of an item to now'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc 'Resume entry (remove @done)'
+  c.switch %i[r resume], default_value: true
+
+  c.desc 'Reset last entry matching tag'
+  c.arg_name 'TAG'
+  c.flag [:tag]
+
+  c.desc 'Reset last entry matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  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.desc 'Select from a menu of matching entries'
+  c.switch %i[i interactive]
+
+  c.action do |global_options, options, args|
+    if options[:section]
+      options[:section] = wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    options[:tag_bool] = options[:bool].normalize_bool
+
+    items = wwid.filter_items([], opt: options)
+
+    if options[:interactive]
+      last_entry = wwid.choose_from_items(items, {
+        menu: true,
+        header: '',
+        prompt: 'Select an entry to start/reset > ',
+        multiple: false,
+        sort: false,
+        show_if_single: true
+      }, include_section: options[:section].nil? )
+    else
+      last_entry = items.last
     end
+
+    unless last_entry
+      Doing.logger.warn('Not found:', 'No entry matching parameters was found.')
+      return
+    end
+
+    wwid.reset_item(last_entry, resume: options[:resume])
+
+    # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
+
+    wwid.write(wwid.doing_file)
   end
 end
 
+
 desc 'Add a note to the last entry'
 long_desc %(
-  If -r is provided with no other arguments, the last note is removed. If new content is specified through arguments or STDIN, any previous note will be replaced with the new one.
+  If -r is provided with no other arguments, the last note is removed.
+  If new content is specified through arguments or STDIN, any previous
+  note will be replaced with the new one.
 
   Use -e to load the last entry in a text editor where you can append a note.
 )
@@ -132,47 +252,77 @@ command :note do |c|
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
   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.arg_name 'TAG'
+  c.flag [:tag]
+
+  c.desc 'Add/remove note from last entry matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  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.desc 'Select item for new note from a menu of matching entries'
+  c.switch %i[i interactive]
+
   c.action do |_global_options, options, args|
     if options[:section]
-      section = wwid.guess_section(options[:section]) || options[:section].cap_first
+      options[:section] = wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    options[:tag_bool] = options[:bool].normalize_bool
+
+    last_entry = wwid.last_entry(options)
+
+    unless last_entry
+      Doing.logger.warn('Not found:', 'No entry matching parameters was found.')
+      return
     end
 
+    last_note = last_entry.note || Doing::Note.new
+    new_note = Doing::Note.new
+
     if options[:e] || (args.empty? && $stdin.stat.size.zero? && !options[:r])
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       input = !args.empty? ? args.join(' ') : ''
 
-      prev_input = wwid.last_note(section) || ''
-      prev_input = prev_input.join("\n") if prev_input.instance_of?(Array)
-      input = prev_input + input
+      if options[:remove]
+        prev_input = Doing::Note.new
+      else
+        prev_input = last_entry.note || Doing::Note.new
+      end
 
-      input = wwid.fork_editor(input).strip
-      exit_now! 'No content, cancelled' unless input
+      input = prev_input.add(input)
 
+      input = wwid.fork_editor([last_entry.title, '### Edit below this line', input.to_s].join("\n")).strip
       _title, note = wwid.format_input(input)
-
-      exit_now! 'No note content' unless note
-
-      wwid.note_last(section, note, replace: true)
+      options[:remove] = true
+      new_note.add(note)
     elsif !args.empty?
-      title, note = wwid.format_input(args.join(' '))
-      note.insert(0, title)
-      wwid.note_last(section, note, replace: options[:r])
+      new_note.add(args.join(' '))
     elsif $stdin.stat.size.positive?
-      title, note = wwid.format_input($stdin.read)
-      note.insert(0, title)
-      wwid.note_last(section, note, replace: options[:r])
-    elsif options[:r]
-      wwid.note_last(section, [], replace: true)
+      new_note.add($stdin.read)
     else
-      exit_now! 'You must provide content when adding a note'
+      raise Doing::Errors::EmptyInput, 'You must provide content when adding a note' unless options[:remove]
     end
+
+    if last_note.equal?(new_note)
+      Doing.logger.debug('Skipped:', 'No note change')
+    else
+      last_note.add(new_note, replace: options[:remove])
+      Doing.logger.info('Entry updated:', last_entry.title)
+    end
+    # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
+
     wwid.write(wwid.doing_file)
   end
 end
@@ -184,7 +334,7 @@ command :meanwhile do |c|
   c.arg_name 'NAME'
   c.flag %i[s section]
 
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc 'Archive previous @meanwhile entry'
@@ -200,9 +350,9 @@ command :meanwhile do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back])
+      date = wwid.chronify(options[:back], guess: :begin)
 
-      exit_now! 'Unable to parse date string' if date.nil?
+      raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
@@ -210,12 +360,12 @@ command :meanwhile do |c|
     if options[:section]
       section = wwid.guess_section(options[:section]) || options[:section].cap_first
     else
-      section = wwid.config['current_section']
+      section = settings['current_section']
     end
     input = ''
 
     if options[:e]
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       input += args.join(' ') unless args.empty?
       input = wwid.fork_editor(input).strip
@@ -248,30 +398,55 @@ long_desc %(
   Templates are printed to STDOUT for piping to a file.
   Save them and use them in the configuration file under html_template.
 
-  Example `doing template HAML > ~/styles/my_doing.haml`
+  Example `doing template haml > ~/styles/my_doing.haml`
 )
-arg_name 'TYPE', must_match: /^(?:html|haml|css|markdown|md|erb)/i
+arg_name 'TYPE', must_match: Doing::Plugins.template_regex
 command :template do |c|
+  c.desc 'List all available templates'
+  c.switch %i[l list]
+
+  c.desc 'List in single column for completion'
+  c.switch %i[c]
+
   c.action do |_global_options, options, args|
-    exit_now! 'No type specified, use `doing template [HAML|CSS|MARKDOWN]`' if args.empty?
-
-    case args[0]
-    when /html|haml/i
-      $stdout.puts wwid.haml_template
-    when /css/i
-      $stdout.puts wwid.css_template
-    when /markdown|md|erb/i
-      $stdout.puts wwid.markdown_template
+    if options[:list] || options[:c]
+      if options[:c]
+        $stdout.print Doing::Plugins.plugin_templates.join("\n")
+      else
+        $stdout.puts "Available templates: #{Doing::Plugins.plugin_templates.join(', ')}"
+      end
+      return
+    end
+
+    if args.empty?
+      type = wwid.choose_from(Doing::Plugins.plugin_templates, sorted: false, prompt: 'Select template type > ')
     else
-      exit_now! 'Invalid type specified, must be HAML or CSS'
+      type = args[0]
     end
+
+    raise Doing::Errors::InvalidPluginType, "No type specified, use `doing template [#{Doing::Plugins.plugin_templates.join('|')}]`" unless type
+
+    $stdout.puts Doing::Plugins.template_for_trigger(type)
+
+    # case args[0]
+    # when /html|haml/i
+    #   $stdout.puts wwid.haml_template
+    # when /css/i
+    #   $stdout.puts wwid.css_template
+    # when /markdown|md|erb/i
+    #   $stdout.puts wwid.markdown_template
+    # else
+    #   exit_now! 'Invalid type specified, must be HAML or CSS'
+    # end
   end
 end
 
-desc 'Display an interactive menu to perform operations (requires fzf)'
+desc 'Display an interactive menu to perform operations'
 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. Return processes the selected entries.'
+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.'
 command :select do |c|
   c.desc 'Select from a specific section'
   c.arg_name 'SECTION'
@@ -296,7 +471,7 @@ command :select do |c|
 
   c.desc 'Initial search query for filtering. Matching is fuzzy. For exact matching, start query with a single quote, e.g. `--query "\'search"'
   c.arg_name 'QUERY'
-  c.flag %i[q query]
+  c.flag %i[q query search]
 
   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
@@ -323,12 +498,17 @@ command :select do |c|
   c.arg_name 'FILE'
   c.flag %i[save_to]
 
-  c.desc 'Output entries to format (doing|taskpaper|csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output entries to format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:doing|taskpaper|html|csv|json|template|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
+
+  c.desc "Copy selection as a new entry with current time and no @done tag. Only works with single selections. Can be combined with --editor."
+  c.switch %i[again resume]
 
   c.action do |_global_options, options, args|
-    exit_now! "--no-menu requires --query" if !options[:menu] && !options[:query]
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise Doing::Errors::InvalidArgument, '--no-menu requires --query' if !options[:menu] && !options[:query]
 
     wwid.interactive(options)
   end
@@ -337,7 +517,7 @@ end
 desc 'Add an item to the Later section'
 arg_name 'ENTRY'
 command :later do |c|
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc 'Backdate start time to date string [4pm|20m|2h|yesterday noon]'
@@ -350,18 +530,18 @@ command :later do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back])
-      exit_now! 'Unable to parse date string' if date.nil?
+      date = wwid.chronify(options[:back], guess: :begin)
+      raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
 
     if options[:editor] || (args.empty? && $stdin.stat.size.zero?)
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       input = args.empty? ? '' : args.join(' ')
       input = wwid.fork_editor(input).strip
-      exit_now! 'No content' unless input && !input.empty?
+      raise Doing::Errors::EmptyInput, 'No content' unless input && !input.empty?
 
       title, note = wwid.format_input(input)
       note.push(options[:n]) if options[:n]
@@ -378,7 +558,7 @@ command :later do |c|
       wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
       wwid.write(wwid.doing_file)
     else
-      exit_now! 'You must provide content when creating a new entry'
+      raise Doing::Errors::EmptyInput, 'You must provide content when creating a new entry'
     end
   end
 end
@@ -414,31 +594,39 @@ command %i[done did] do |c|
   c.arg_name 'NAME'
   c.flag %i[s section]
 
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.desc "Edit entry with #{Doing::Util.default_editor} (with no arguments, edits the last entry)"
   c.switch %i[e editor], negatable: false, default_value: false
 
+  c.desc 'Include a note'
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
+
+  c.desc 'Finish last entry not already marked @done'
+  c.switch %i[u unfinished], negatable: false, default_value: false
+
   # c.desc "Edit entry with specified app"
   # c.arg_name 'editor_app'
   # # c.flag [:a, :app]
 
   c.action do |_global_options, options, args|
     took = 0
+    donedate = nil
 
     if options[:took]
       took = wwid.chronify_qty(options[:took])
-      exit_now! 'Unable to parse date string for --took' if took.nil?
+      raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
     end
 
     if options[:back]
-      date = wwid.chronify(options[:back])
-      exit_now! 'Unable to parse date string for --back' if date.nil?
+      date = wwid.chronify(options[:back], guess: :begin)
+      raise Doing::Errors::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])
-      exit_now! 'Unable to parse date string for --at' if finish_date.nil?
+      finish_date = wwid.chronify(options[:at], guess: :begin)
+      raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
       date = options[:took] ? finish_date - took : finish_date
     elsif options[:took]
@@ -449,58 +637,116 @@ command %i[done did] do |c|
       finish_date = Time.now
     end
 
-    if finish_date
-      donedate = options[:date] ? "(#{finish_date.strftime('%F %R')})" : ''
+    if options[:date]
+      donedate = finish_date.strftime('%F %R')
     end
 
     if options[:section]
       section = wwid.guess_section(options[:section]) || options[:section].cap_first
     else
-      section = wwid.config['current_section']
+      section = settings['current_section']
     end
 
+    note = Doing::Note.new
+    note.add(options[:note]) if options[:note]
+
     if options[:editor]
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+      is_new = false
+
+      if args.empty?
+        last_entry = wwid.filter_items([], opt: {unfinished: options[:unfinished], section: section, count: 1, age: 'new'}).max_by { |item| item.date }
+
+        unless last_entry
+          Doing.logger.debug('Skipped:', options[:unfinished] ? 'No unfinished entry' : 'Last entry already @done')
+          raise Doing::Errors::NoResults, 'No results'
+        end
+
+        old_entry = last_entry.dup
+        last_entry.note.add(note)
+        input = [last_entry.title, last_entry.note.to_s].join("\n")
+      else
+        is_new = true
+        input = [args.join(' '), note.to_s].join("\n")
+      end
 
-      input = ''
-      input += args.join(' ') unless args.empty?
       input = wwid.fork_editor(input).strip
-      exit_now! 'No content' unless input && !input.empty?
+      raise Doing::Errors::EmptyInput, 'No content' unless input && !input.empty?
 
       title, note = wwid.format_input(input)
-      title += " @done#{donedate}"
-      section = 'Archive' if options[:a]
-      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      new_entry = Doing::Item.new(date, title, section, note)
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+
+      if (is_new)
+        wwid.content[section][:items].push(new_entry)
+      else
+        wwid.update_item(old_entry, new_entry)
+      end
+
+      if options[:a]
+        wwid.move_item(new_entry, 'Archive', label: true)
+      end
+
       wwid.write(wwid.doing_file)
     elsif args.empty? && $stdin.stat.size.zero?
       if options[:r]
         wwid.tag_last({ tags: ['done'], count: 1, section: section, remove: true })
       else
-        options = { tags: ['done'],
+        note = options[:note] ? Doing::Note.new(options[:note]) : nil
+        opt = {
           archive: options[:a],
           back: finish_date,
           count: 1,
           date: options[:date],
+          note: note,
           section: section,
-          took: took == 0 ? nil : took
+          tags: ['done'],
+          took: took == 0 ? nil : took,
+          unfinished: options[:unfinished]
         }
-        wwid.tag_last(options)
+        wwid.tag_last(opt)
       end
     elsif !args.empty?
-      title, note = wwid.format_input(args.join(' '))
+      note = Doing::Note.new(options[:note])
+      title, new_note = wwid.format_input([args.join(' '), note.to_s].join("\n"))
       title.chomp!
-      title += " @done#{donedate}"
       section = 'Archive' if options[:a]
-      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      new_entry = Doing::Item.new(date, title, section, new_note)
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+      wwid.content[section][:items].push(new_entry)
       wwid.write(wwid.doing_file)
+      Doing.logger.info('Entry Added:', new_entry.title)
     elsif $stdin.stat.size.positive?
       title, note = wwid.format_input($stdin.read)
-      title += " @done#{donedate}"
+      note.add(options[:note]) if options[:note]
       section = options[:a] ? 'Archive' : section
-      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      new_entry = Doing::Item.new(date, title, section, note)
+
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+
+      wwid.content[section][:items].push(new_entry)
       wwid.write(wwid.doing_file)
+      Doing.logger.info('Entry Added:', new_entry.title)
     else
-      exit_now! 'You must provide content when creating a new entry'
+      raise Doing::Errors::EmptyInput, 'You must provide content when creating a new entry'
     end
   end
 end
@@ -522,39 +768,37 @@ command :cancel do |c|
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
 
   c.desc 'Cancel last entry (or entries) not already marked @done'
   c.switch %i[u unfinished], negatable: false, default_value: false
 
+  c.desc 'Select item(s) to cancel from a menu of matching entries'
+  c.switch %i[i interactive]
+
   c.action do |_global_options, options, args|
     if options[:section]
       section = wwid.guess_section(options[:section]) || options[:section].cap_first
     else
-      section = wwid.config['current_section']
+      section = settings['current_section']
     end
 
     if options[:tag].nil?
       tags = []
     else
-      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
-      options[:bool] = case options[:bool]
-                       when /(and|all)/i
-                        'AND'
-                       when /(any|or)/i
-                        'OR'
-                       when /(not|none)/i
-                        'NOT'
-                       else
-                        'AND'
-                       end
+      tags = options[:tag].to_tags
     end
 
-    exit_now! 'Only one argument allowed' if args.length > 1
+    raise Doing::Errors::InvalidArgument, 'Only one argument allowed' if args.length > 1
 
-    exit_now! 'Invalid argument (specify number of recent items to mark @done)' unless args.empty? || args[0] =~ /\d+/
+    raise Doing::Errors::InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)' unless args.empty? || args[0] =~ /\d+/
+
+    if options[:interactive]
+      count = 0
+    else
+      count = args[0] ? args[0].to_i : 1
+    end
 
-    count = args[0] ? args[0].to_i : 1
     opts = {
       archive: options[:a],
       count: count,
@@ -562,10 +806,12 @@ command :cancel do |c|
       section: section,
       sequential: false,
       tag: tags,
-      tag_bool: options[:bool],
+      tag_bool: options[:bool].normalize_bool,
       tags: ['done'],
-      unfinished: options[:unfinished]
+      unfinished: options[:unfinished],
+      interactive: options[:interactive]
     }
+
     wwid.tag_last(opts)
   end
 end
@@ -594,13 +840,16 @@ command :finish do |c|
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Finish the last X entries matching search filter, surround with slashes for regex (e.g. "/query.*/")'
+  c.desc 'Finish 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'
   c.flag [:search]
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+
+  c.desc 'Remove done tag'
+  c.switch %i[r remove], negatable: false, default_value: false
 
   c.desc 'Finish last entry (or entries) not already marked @done'
   c.switch %i[u unfinished], negatable: false, default_value: false
@@ -617,32 +866,29 @@ command :finish do |c|
   c.arg_name 'NAME'
   c.flag %i[s section]
 
-  c.action do |_global_options, options, args|
-    if options[:section]
-      section = wwid.guess_section(options[:section]) || options[:section].cap_first
-    else
-      section = wwid.config['current_section']
-    end
+  c.desc 'Select item(s) to finish from a menu of matching entries'
+  c.switch %i[i interactive]
 
+  c.action do |_global_options, options, args|
     unless options[:auto]
       if options[:took]
         took = wwid.chronify_qty(options[:took])
-        exit_now! 'Unable to parse date string for --took' if took.nil?
+        raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
       end
 
-      exit_now! '--back and --took cannot be used together' if options[:back] && options[:took]
+      raise Doing::Errors::InvalidArgument, '--back and --took can not be used together' if options[:back] && options[:took]
 
-      exit_now! '--search and --tag cannot be used together' if options[:search] && options[:tag]
+      raise Doing::Errors::InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
 
       if options[:at]
-        finish_date = wwid.chronify(options[:at])
-        exit_now! 'Unable to parse date string for --at' if finish_date.nil?
+        finish_date = wwid.chronify(options[:at], guess: :begin)
+        raise Doing::Errors::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])
 
-        exit_now! 'Unable to parse date string' if date.nil?
+        raise Doing::Errors::InvalidTimeExpression, 'Unable to parse date string' if date.nil?
       elsif options[:took]
         date = wwid.chronify_qty(options[:took])
       else
@@ -653,44 +899,42 @@ command :finish do |c|
     if options[:tag].nil?
       tags = []
     else
-      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
-      options[:bool] = case options[:bool]
-                             when /(and|all)/i
-                              'AND'
-                             when /(any|or)/i
-                              'OR'
-                             when /(not|none)/i
-                              'NOT'
-                             else
-                              'AND'
-                             end
+      tags = options[:tag].to_tags
     end
 
-    exit_now! 'Only one argument allowed' if args.length > 1
+    raise Doing::Errors::InvalidArgument, 'Only one argument allowed' if args.length > 1
+
+    raise Doing::Errors::InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)' unless args.length == 0 || args[0] =~ /\d+/
 
-    exit_now! 'Invalid argument (specify number of recent items to mark @done)' unless args.length == 0 || args[0] =~ /\d+/
+    if options[:interactive]
+      count = 0
+    else
+      count = args[0] ? args[0].to_i : 1
+    end
 
-    count = args[0] ? args[0].to_i : 1
     opts = {
-      archive: options[:a],
+      archive: options[:archive],
       back: date,
       count: count,
       date: options[:date],
       search: options[:search],
-      section: section,
+      section: options[:section],
       sequential: options[:auto],
       tag: tags,
-      tag_bool: options[:bool],
+      tag_bool: options[:bool].normalize_bool,
       tags: ['done'],
-      unfinished: options[:unfinished]
+      unfinished: options[:unfinished],
+      remove: options[:remove],
+      interactive: options[:interactive]
     }
+
     wwid.tag_last(opts)
   end
 end
 
 desc 'Repeat last entry as new entry'
-command [:again, :resume] do |c|
-  c.desc 'Section'
+command %i[again resume] do |c|
+  c.desc 'Get last entry from a specific section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
@@ -703,45 +947,38 @@ command [:again, :resume] do |c|
   c.flag [:tag]
 
   c.desc 'Repeat last entry matching search. Surround with
-  slashes for regex (e.g. "/query/").'
+  slashes for regex (e.g. "/query/"), start with a single quote for exact match ("\'query").'
   c.arg_name 'QUERY'
   c.flag [:search]
 
   c.desc 'Boolean used to combine multiple tags'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+
+  c.desc "Edit duplicated entry with #{Doing::Util.default_editor} before adding"
+  c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc 'Note'
   c.arg_name 'TEXT'
   c.flag %i[n note]
 
+  c.desc 'Select item to resume from a menu of matching entries'
+  c.switch %i[i interactive]
+
   c.action do |_global_options, options, _args|
-    tags = options[:tag].nil? ? [] : options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }
-    options[:bool] = case options[:bool]
-                     when /(and|all)/i
-                      'AND'
-                     when /(any|or)/i
-                      'OR'
-                     when /(not|none)/i
-                      'NOT'
-                     else
-                      'AND'
-                     end
-    opts = {
-      in: options[:in],
-      note: options[:n],
-      search: options[:search],
-      section: options[:s],
-      tag: tags,
-      tag_bool: options[:bool]
-    }
-    wwid.restart_last(opts)
+    tags = options[:tag].nil? ? [] : options[:tag].to_tags
+    opts = options
+    opts[:tag] = tags
+    opts[:tag_bool] = options[:bool].normalize_bool
+    opts[:interactive] = options[:interactive]
+
+    wwid.repeat_last(opts)
   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
+          (with `--count`), entries matching a search (with `--search`), or entries
           containing another tag (with `--tag`).
 
           When removing tags with `-r`, wildcards are allowed (`*` to match
@@ -755,13 +992,19 @@ long_desc 'Add (or remove) tags from the last entry, or from multiple entries
           Tag name arguments do not need to be prefixed with @.'
 arg_name 'TAG', :multiple
 command :tag do |c|
+  c.example 'doing tag mytag', desc: 'Add @mytag to the last entry created'
+  c.example 'doing tag --remove mytag', desc: 'Remove @mytag from the last entry created'
+  c.example 'doing tag --rename "other*" --count 10 newtag', desc: 'Rename tags beginning with "other" (wildcard) to @newtag on the last 10 entries'
+  c.example 'doing tag --search "developing" coding', desc: 'Add @coding to the last entry containing string "developing" (fuzzy matching)'
+  c.example 'doing tag --interactive --tag project1 coding', desc: 'Create an interactive menu from entries tagged @project1, selection(s) will be tagged with @coding'
+
   c.desc 'Section'
   c.arg_name 'SECTION_NAME'
   c.flag %i[s section], default_value: 'All'
 
   c.desc 'How many recent entries to tag (0 for all)'
   c.arg_name 'COUNT'
-  c.flag %i[c count], default_value: 1
+  c.flag %i[c count], default_value: 1, must_match: /^\d+$/, type: Integer
 
   c.desc 'Replace existing tag with tag argument, wildcards (*,?) allowed, or use with --regex'
   c.arg_name 'ORIG_TAG'
@@ -790,18 +1033,21 @@ command :tag do |c|
   c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag entries matching search filter, surround with slashes for regex (e.g. "/query.*/")'
+  c.desc 'Tag entries matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
   c.flag [:search]
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
+
+  c.desc 'Select item(s) to tag from a menu of matching entries'
+  c.switch %i[i interactive]
 
   c.action do |_global_options, options, args|
-    exit_now! 'You must specify at least one tag' if args.empty? && !options[:a]
+    raise Doing::Errors::MissingArgument, 'You must specify at least one tag' if args.empty? && !options[:a]
 
-    exit_now! '--search and --tag cannot be used together' if options[:search] && options[:tag]
+    raise Doing::Errors::InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
 
     section = 'All'
 
@@ -813,17 +1059,7 @@ command :tag do |c|
     if options[:tag].nil?
       search_tags = []
     else
-      search_tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
-      options[:bool] = case options[:bool]
-                             when /(and|all)/i
-                              'AND'
-                             when /(any|or)/i
-                              'OR'
-                             when /(not|none)/i
-                              'NOT'
-                             else
-                              'AND'
-                             end
+      search_tags = options[:tag].to_tags
     end
 
     if options[:autotag]
@@ -838,7 +1074,13 @@ command :tag do |c|
       tags.map! { |tag| tag.sub(/^@/, '').strip }
     end
 
-    count = options[:count].to_i
+    if options[:interactive]
+      count = 0
+      options[:force] = true
+    else
+      count = options[:count].to_i
+    end
+
 
     if count.zero? && !options[:force]
       if options[:search]
@@ -869,45 +1111,121 @@ command :tag do |c|
     options[:section] = section
     options[:tag] = search_tags
     options[:tags] = tags
-    options[:tag_bool] = options[:bool]
-
-    # opts = {
-    #   autotag: options[:a],
-    #   count: count,
-    #   date: options[:date],
-    #   iregex: options[:iregex]
-    #   remove: options[:r],
-    #   search: options[:search],
-    #   section: section,
-    #   tag: search_tags,
-    #   tag_bool: options[:bool],
-    #   tags: tags,
-    #   unfinished: options[:unfinished]
-    # }
+    options[:tag_bool] = options[:bool].normalize_bool
+
     wwid.tag_last(options)
   end
 end
 
-desc 'Mark last entry as highlighted'
+# desc 'Autotag last X entries'
+# arg_name 'COUNT'
+# command :autotag do |c|
+#   c.action do |global_options, options, args|
+#     options = {
+#       autotag: true,
+#       count: args[0].to_i
+#     }
+#     cmd = commands[:tag]
+#     cmd.action.(global_options, options, [])
+#   end
+# end
+
+desc 'Mark last entry as flagged'
 command [:mark, :flag] do |c|
+  c.example 'doing flag', desc: 'Add @flagged to the last entry created'
+  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'
+
   c.desc 'Section'
-  c.arg_name 'NAME'
-  c.flag %i[s section]
+  c.arg_name 'SECTION_NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc 'How many recent entries to tag (0 for all)'
+  c.arg_name 'COUNT'
+  c.flag %i[c count], default_value: 1, must_match: /^\d+$/, type: Integer
+
+  c.desc 'Don\'t ask permission to flag all entries when count is 0'
+  c.switch %i[force], negatable: false, default_value: false
 
-  c.desc 'Remove mark'
+  c.desc 'Include current date/time with tag'
+  c.switch %i[d date], negatable: false, default_value: false
+
+  c.desc 'Remove flag'
   c.switch %i[r remove], negatable: false, default_value: false
 
-  c.desc 'Mark last entry not marked @done'
+  c.desc 'Flag last entry (or entries) not marked @done'
   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'
+  c.arg_name 'TAG'
+  c.flag [:tag]
+
+  c.desc 'Flag the last entry matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  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.desc 'Select item(s) to flag from a menu of matching entries'
+  c.switch %i[i interactive]
+
   c.action do |_global_options, options, _args|
-    mark = wwid.config['marker_tag'] || 'flagged'
-    wwid.tag_last({
-      remove: options[:r],
-      section: options[:s],
-      tags: [mark],
-      unfinished: options[:unfinished]
-    })
+    mark = settings['marker_tag'] || 'flagged'
+
+    raise Doing::Errors::InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
+
+    section = 'All'
+
+    if options[:section]
+      section = wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    if options[:tag].nil?
+      search_tags = []
+    else
+      search_tags = options[:tag].to_tags
+    end
+
+    if options[:interactive]
+      count = 0
+      options[:force] = true
+    else
+      count = options[:count].to_i
+    end
+
+    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
+
+
+      question = if options[:remove]
+                   "Are you sure you want to unflag all entries#{section_q}"
+                 else
+                   "Are you sure you want to flag all records#{section_q}"
+                 end
+
+      res = wwid.yn(question, default_response: false)
+
+      exit_now! 'Cancelled' unless res
+    end
+
+    options[:count] = count
+    options[:section] = section
+    options[:tag] = search_tags
+    options[:tags] = [mark]
+    options[:tag_bool] = options[:bool].normalize_bool
+
+    wwid.tag_last(options)
   end
 end
 
@@ -918,13 +1236,19 @@ long_desc %(
 )
 arg_name '[SECTION|@TAGS]'
 command :show do |c|
+  c.example 'doing show Currently', desc: 'Show entries in the Currently section'
+  c.example 'doing show @project1', desc: 'Show entries tagged @project1'
+  c.example 'doing show Later @doing', desc: 'Show entries from the Later section tagged @doing'
+  c.example 'doing show Ideas --from "mon to fri" --tag doing', 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.arg_name 'TAG'
   c.flag [:tag]
 
   c.desc 'Tag boolean (AND,OR,NOT)'
   c.arg_name 'BOOLEAN'
-  c.flag %i[b bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'OR'
+  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'OR'
 
   c.desc 'Max count to show'
   c.arg_name 'MAX'
@@ -942,13 +1266,13 @@ command :show do |c|
   c.arg_name 'DATE_STRING'
   c.flag [:after]
 
-  c.desc 'Search filter, surround with slashes for regex (/query/)'
+  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 'Sort order (asc/desc)'
   c.arg_name 'ORDER'
-  c.flag %i[s sort], must_match: /^[ad].*/i, default_value: 'ASC'
+  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.
@@ -966,21 +1290,26 @@ command :show do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)/i, default_value: default
 
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
-  c.flag [:tag_order], must_match: /^(?:a(?:sc)?|d(?:esc)?)$/i
+  c.flag [:tag_order], must_match: REGEX_SORT_ORDER, default_value: 'asc'
 
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc 'Select from a menu of matching entries to perform additional operations'
+  c.switch %i[i interactive]
+
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
   c.action do |_global_options, options, args|
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
     tag_filter = false
     tags = []
     if args.length.positive?
@@ -995,7 +1324,7 @@ command :show do |c|
         section = 'All'
       else
         section = wwid.guess_section(args[0])
-        exit_now! "No such section: #{args[0]}" unless section
+        raise Doing::Errors::InvalidSection, "No such section: #{args[0]}" unless section
 
         args.shift
       end
@@ -1007,72 +1336,51 @@ command :show do |c|
         end
       end
     else
-      section = wwid.current_section
+      section = settings['current_section']
     end
 
-    tags.concat(options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if options[:tag]
-    options[:bool] = case options[:bool]
-                     when /(and|all)/i
-                      'AND'
-                     when /(any|or)/i
-                      'OR'
-                     when /(not|none)/i
-                      'NOT'
-                     else
-                      'AND'
-                     end
+    tags.concat(options[:tag].to_tags) if options[:tag]
 
     unless tags.empty?
       tag_filter = {
         'tags' => tags,
-        'bool' => options[:bool]
+        'bool' => options[:bool].normalize_bool
       }
     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])
-        finish = wwid.chronify(dates[2])
+        start = wwid.chronify(dates[0], guess: :begin)
+        finish = wwid.chronify(dates[2], guess: :end)
       else
-        start = wwid.chronify(date_string)
+        start = wwid.chronify(date_string, guess: :begin)
         finish = false
       end
-      exit_now! 'Unrecognized date string' unless start
+      raise Doing::Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
       dates = [start, finish]
     end
 
     options[:times] = true if options[:totals]
 
-    tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
+    tags_color = settings.key?('tags_color') ? settings['tags_color'] : nil
 
-    options[:sort_tags] = options[:tag_sort] =~ /^n/i
-    tag_order = if options[:tag_order]
-                  options[:tag_order] =~ /^d/i ? 'desc' : 'asc'
-                else
-                  'asc'
-                end
-    opts = {
-      after: options[:after],
-      age: options[:age],
-      before: options[:before],
-      count: options[:c].to_i,
-      date_filter: dates,
-      highlight: true,
-      only_timed: options[:only_timed],
-      order: options[:s],
-      output: options[:output],
-      search: options[:search],
-      section: section,
-      sort_tags: options[:sort_tags],
-      tag_filter: tag_filter,
-      tag_order: tag_order,
-      tags_color: tags_color,
-      times: options[:t],
-      totals: options[:totals]
-    }
-    puts wwid.list_section(opts)
+    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
+    opt[:tag] = nil
+    opt[:tag_filter] = tag_filter
+    opt[:tag_order] = options[:tag_order].normalize_order
+    opt[:tags_color] = tags_color
+
+    Doing::Pager.page wwid.list_section(opt)
   end
 end
 
@@ -1084,7 +1392,12 @@ long_desc <<~'EODESC'
 EODESC
 
 arg_name 'SEARCH_PATTERN'
-command [:grep, :search] do |c|
+command %i[grep search] do |c|
+  c.example 'doing grep "doing wiki"', desc: 'Find entries containing "doing wiki" using fuzzy matching'
+  c.example 'doing search "\'search command"', desc: 'Find entries containing "search command" using exact matching (search is an alias for grep)'
+  c.example 'doing grep "/do.*?wiki.*?@done/"', desc: 'Find entries matching regular expression'
+  c.example 'doing search --before 12/21 "doing wiki"', desc: 'Find entries containing "doing wiki" with entry dates before 12/21 of the current year'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1097,9 +1410,9 @@ command [:grep, :search] do |c|
   c.arg_name 'DATE_STRING'
   c.flag [:after]
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
@@ -1109,36 +1422,31 @@ command [:grep, :search] do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
+  c.desc 'Display an interactive menu of results to perform further operations'
+  c.switch %i[i interactive], default_value: false, negatable: false
+
   c.action do |_global_options, options, args|
-    tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    tags_color = settings.key?('tags_color') ? settings['tags_color'] : nil
 
-    section = wwid.guess_section(options[:s]) if options[:s]
+    section = wwid.guess_section(options[:section]) if options[:section]
 
     options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
+    options[:highlight] = true
+    options[:search] = args.join(' ')
+    options[:section] = section
+    options[:tags_color] = tags_color
 
-    opts = {
-      after: options[:after],
-      before: options[:before],
-      highlight: true,
-      only_timed: options[:only_timed],
-      output: options[:output],
-      search: args.join(' '),
-      section: section,
-      sort_tags: options[:sort_tags],
-      tags_color: tags_color,
-      times: options[:times],
-      totals: options[:totals]
-    }
-
-    puts wwid.list_section(opts)
+    Doing::Pager.page wwid.list_section(options)
   end
 end
 
@@ -1146,6 +1454,11 @@ desc 'List recent entries'
 default_value 10
 arg_name 'COUNT'
 command :recent do |c|
+  c.example 'doing recent', desc: 'Show the 10 most recent entries across all sections'
+  c.example 'doing recent 20', desc: 'Show the 20 most recent entries across all sections'
+  c.example 'doing recent --section Currently 20', desc: 'List the 20 most recent entries from the Currently section'
+  c.example 'doing recent --interactive 20', desc: 'Create a menu from the 20 most recent entries to perform batch actions on'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1158,32 +1471,42 @@ command :recent do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
+  c.desc 'Select from a menu of matching entries to perform additional operations'
+  c.switch %i[i interactive]
+
   c.action do |global_options, options, args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
     unless global_options[:version]
-      if wwid.config['templates']['recent'].key?('count')
-        config_count = wwid.config['templates']['recent']['count'].to_i
+      if settings['templates']['recent'].key?('count')
+        config_count = settings['templates']['recent']['count'].to_i
       else
         config_count = 10
       end
-      count = args.empty? ? config_count : args[0].to_i
+
+      if options[:interactive]
+        count = 0
+      else
+        count = args.empty? ? config_count : args[0].to_i
+      end
+
       options[:t] = true if options[:totals]
       options[:sort_tags] = options[:tag_sort] =~ /^n/i
-      tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
+      tags_color = settings.key?('tags_color') ? settings['tags_color'] : nil
 
       opts = {
         sort_tags: options[:sort_tags],
         tags_color: tags_color,
         times: options[:t],
-        totals: options[:totals]
+        totals: options[:totals],
+        interactive: options[:interactive]
       }
 
-      puts wwid.recent(count, section.cap_first, opts)
+      Doing::Pager::page wwid.recent(count, section.cap_first, opts)
 
     end
   end
@@ -1191,6 +1514,11 @@ end
 
 desc 'List entries from today'
 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'
+  c.example 'doing today --before 3pm --after 12pm', desc: 'List entries with start dates between 12pm and 3pm today'
+  c.example 'doing today --output json', desc: 'Output entries from today in JSON format'
+
   c.desc 'Specify a section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1203,13 +1531,13 @@ command :today do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.desc 'View entries before specified time (e.g. 8am, 12:30pm, 15:00)'
   c.arg_name 'TIME_STRING'
@@ -1220,6 +1548,8 @@ command :today do |c|
   c.flag [:after]
 
   c.action do |_global_options, options, _args|
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
     opt = {
@@ -1227,9 +1557,10 @@ command :today do |c|
       before: options[:before],
       section: options[:section],
       sort_tags: options[:sort_tags],
-      totals: options[:totals]
+      totals: options[:totals],
+      order: settings.dig('templates', 'today', 'order')
     }
-    puts wwid.today(options[:times], options[:output], opt).chomp
+    Doing::Pager.page wwid.today(options[:times], options[:output], opt).chomp
   end
 end
 
@@ -1239,6 +1570,10 @@ and "2d" would be interpreted as "two days ago." If you use "to" or "through" be
 it will create a range.)
 arg_name 'DATE_STRING'
 command :on do |c|
+  c.example 'doing on friday', desc: 'List entries between 12am and 11:59PM last Friday'
+  c.example 'doing on 12/21/2020', desc: 'List entries from Dec 21, 2020'
+  c.example 'doing on "3d to 1d"', desc: 'List entries added between 3 days ago and 1 day ago'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1251,38 +1586,40 @@ command :on do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.action do |_global_options, options, args|
-    exit_now! 'Missing date argument' if args.empty?
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise Doing::Errors::MissingArgument, 'Missing date argument' if args.empty?
 
     date_string = args.join(' ')
 
     if date_string =~ / (to|through|thru) /
       dates = date_string.split(/ (to|through|thru) /)
-      start = wwid.chronify(dates[0])
-      finish = wwid.chronify(dates[2])
+      start = wwid.chronify(dates[0], guess: :begin)
+      finish = wwid.chronify(dates[2], guess: :end)
     else
-      start = wwid.chronify(date_string)
+      start = wwid.chronify(date_string, guess: :begin)
       finish = false
     end
 
-    exit_now! 'Unrecognized date string' unless start
+    raise Doing::Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
 
     message = "Date interpreted as #{start}"
     message += " to #{finish}" if finish
-    wwid.results.push(message)
+    Doing.logger.debug(message)
 
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    puts wwid.list_date([start, finish], options[:s], options[:t], options[:output],
+    Doing::Pager.page wwid.list_date([start, finish], options[:s], options[:t], options[:output],
                         { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
@@ -1292,6 +1629,9 @@ long_desc %(Date argument can be natural language and are always interpreted as
 and "2d" would be interpreted as "two days ago.")
 arg_name 'DATE_STRING'
 command :since do |c|
+  c.example 'doing since 7/30', desc: 'List all entries created since 12am on 7/30 of the current year'
+  c.example 'doing since "monday 3pm" --output json', desc: 'Show entries since 3pm on Monday of the current week, output in JSON format'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
@@ -1304,47 +1644,52 @@ command :since do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.action do |_global_options, options, args|
-    exit_now! 'Missing date argument' if args.empty?
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise Doing::Errors::MissingArgument, 'Missing date argument' if args.empty?
 
     date_string = args.join(' ')
 
-    date_string += ' at midnight' unless date_string =~ /(\d:|\d *[ap]m?|midnight|noon)/i
-    date_string.sub!(/(day) (\d)/, '\1 at \2') if date_string =~ /day \d/
+    date_string.sub!(/(day) (\d)/, '\1 at \2')
+    date_string.sub!(/(\d+)d( ago)?/, '\1 days ago')
 
-    start = wwid.chronify(date_string)
+    start = wwid.chronify(date_string, guess: :begin)
     finish = Time.now
 
-    exit_now! 'Unrecognized date string' unless start
+    raise Doing::Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
 
-    message = "Date interpreted as #{start} through the current time"
-    wwid.results.push(message)
+    Doing.logger.debug("Date interpreted as #{start} through the current time")
 
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    puts wwid.list_date([start, finish], options[:s], options[:t], options[:output],
+    Doing::Pager.page wwid.list_date([start, finish], options[:s], options[:t], options[:output],
                         { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
 desc 'List entries from yesterday'
 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'
+  c.example 'doing yesterday --totals', desc: 'List entries from previous day, including tag timers'
+
   c.desc 'Specify a section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
@@ -1354,7 +1699,7 @@ command :yesterday do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  default = settings['tag_sort'] || 'name'
   c.arg_name 'KEY'
   c.flag [:tag_sort], must_match: /^(?:name|time)$/i, default_value: default
 
@@ -1368,33 +1713,40 @@ command :yesterday do |c|
 
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
-  c.flag [:tag_order], must_match: /^(?:a(?:sc)?|d(?:esc)?)$/i
+  c.flag [:tag_order], must_match: REGEX_SORT_ORDER, default_value: 'asc'
 
   c.action do |_global_options, options, _args|
-    tag_order = if options[:tag_order]
-                  options[:tag_order] =~ /^d/i ? 'desc' : 'asc'
-                else
-                  'asc'
-                end
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
+
     opt = {
       after: options[:after],
       before: options[:before],
       sort_tags: options[:sort_tags],
-      tag_order: options[:tag_order],
-      totals: options[:totals]
+      tag_order: options[:tag_order].normalize_order,
+      totals: options[:totals],
+      order: settings.dig('templates', 'today', 'order')
     }
-    puts wwid.yesterday(options[:section], options[:times], options[:output], opt).chomp
+    Doing::Pager.page wwid.yesterday(options[:section], options[:times], options[:output], opt).chomp
   end
 end
 
 desc 'Show the last entry, optionally edit'
 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'
+  c.example 'doing last --tag project1,work --bool AND', desc: 'Show most recent entry tagged @project1 and @work'
+  c.example 'doing last --search "side hustle"', desc: 'Show most recent entry containing "side hustle" (fuzzy matching)'
+  c.example 'doing last --search "\'side hustle"', desc: 'Show most recent entry containing "side hustle" (exact match)'
+  c.example 'doing last --edit', desc: 'Open the most recent entry in an editor for modifications'
+  c.example 'doing last --search "\'side hustle" --edit', desc: 'Open most recent entry containing "side hustle" (exact match) in editor'
+
   c.desc 'Specify a section'
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc "Edit entry with #{ENV['EDITOR']}"
+  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.'
@@ -1403,19 +1755,19 @@ command :last do |c|
 
   c.desc 'Tag boolean'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
 
-  c.desc 'Search filter, surround with slashes for regex (/query/)'
+  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.action do |_global_options, options, _args|
-    exit_now! '--tag and --search cannot be used together' if options[:tag] && options[:search]
+  c.action do |global_options, options, _args|
+    raise Doing::Errors::InvalidArgument, '--tag and --search can not be used together' if options[:tag] && options[:search]
 
     if options[:tag].nil?
       tags = []
     else
-      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
+      tags = options[:tag].to_tags
       options[:bool] = case options[:bool]
                        when /(any|or)/i
                         :or
@@ -1430,7 +1782,7 @@ command :last do |c|
     if options[:editor]
       wwid.edit_last(section: options[:s], options: { search: options[:search], tag: tags, tag_bool: options[:bool] })
     else
-      puts wwid.last(times: true, section: options[:s],
+      Doing::Pager::page wwid.last(times: true, section: options[:s],
                      options: { search: options[:search], tag: tags, tag_bool: options[:bool] }).strip
     end
   end
@@ -1452,17 +1804,19 @@ command :choose do |c|
   c.action do |_global_options, _options, _args|
     section = wwid.choose_section
 
-    puts wwid.list_section({ section: section.cap_first, count: 0 }) if section
+    Doing::Pager.page wwid.list_section({ section: section.cap_first, count: 0 }) if section
   end
 end
 
 desc 'Add a new section to the "doing" file'
 arg_name 'SECTION_NAME'
 command :add_section do |c|
+  c.example 'doing add_section Ideas', desc: 'Add a section called Ideas to the doing file'
+
   c.action do |_global_options, _options, args|
-    exit_now! "Section #{args[0]} already exists" if wwid.sections.include?(args[0])
+    raise Doing::Errors::InvalidArgument, "Section #{args[0]} already exists" if wwid.sections.include?(args[0])
 
-    wwid.add_section(args[0].cap_first)
+    wwid.add_section(args.join(' ').cap_first)
     wwid.write(wwid.doing_file)
   end
 end
@@ -1470,18 +1824,42 @@ end
 desc 'List available color variables for configuration templates and views'
 command :colors do |c|
   c.action do |_global_options, _options, _args|
-    clrs = wwid.colors
     bgs = []
     fgs = []
-    clrs.each do |k, v|
-      if k =~ /bg/
-        bgs.push("#{v}    #{clrs['default']} <-- #{k}")
+    colors::attributes.each do |color|
+      if color.to_s =~ /bg/
+        bgs.push("#{colors.send(color, "    ")}#{colors.default} <-- #{color.to_s}")
       else
-        fgs.push("#{v}XXXX#{clrs['default']} <-- #{k}")
+        fgs.push("#{colors.send(color, "XXXX")}#{colors.default} <-- #{color.to_s}")
       end
     end
-    puts fgs.join("\n")
-    puts bgs.join("\n")
+    out = []
+    out << fgs.join("\n")
+    out << bgs.join("\n")
+    Doing::Pager.page out.join("\n")
+  end
+end
+
+desc 'List installed plugins'
+long_desc %(Lists available plugins, including user-installed plugins.
+
+Export plugins are available with the `--output` flag on commands that support it.
+
+Import plugins are available using `doing import --type PLUGIN`.
+)
+command :plugins do |c|
+  c.example 'doing plugins', desc: 'List all plugins'
+  c.example 'doing plugins -t import', desc: 'List all import plugins'
+
+  c.desc 'List plugins of type (import, export)'
+  c.arg_name 'TYPE'
+  c.flag %i[t type], must_match: /^[iea].*$/i, default_value: 'all'
+
+  c.desc 'List in single column for completion'
+  c.switch %i[c column], default_value: false
+
+  c.action do |_global_options, options, _args|
+    Doing::Plugins.list_plugins(options)
   end
 end
 
@@ -1489,6 +1867,9 @@ desc 'Display a user-created view'
 long_desc '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"'
+  c.example 'doing view color --section Archive --count 10', desc: 'Display view "color", overriding some configured settings'
+
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section]
@@ -1497,9 +1878,9 @@ command :view do |c|
   c.arg_name 'COUNT'
   c.flag %i[c count], must_match: /^\d+$/, type: Integer
 
-  c.desc 'Output to export format (csv|html|json|template|timeline|taskpaper|markdown)'
+  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
-  c.flag %i[o output], must_match: /^(?:template|html|csv|json|timeline|taskpaper|markdown|md)$/i
+  c.flag %i[o output]
 
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
@@ -1516,9 +1897,9 @@ command :view do |c|
 
   c.desc 'Tag boolean (AND,OR,NOT)'
   c.arg_name 'BOOLEAN'
-  c.flag %i[b bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'OR'
+  c.flag %i[b bool], must_match: REGEX_BOOL, default_value: 'OR'
 
-  c.desc 'Search filter, surround with slashes for regex (/query/)'
+  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]
 
@@ -1528,7 +1909,7 @@ command :view do |c|
 
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
-  c.flag [:tag_order], must_match: /^(?:a(?:sc)?|d(?:esc)?)$/i
+  c.flag [:tag_order], must_match: REGEX_SORT_ORDER
 
   c.desc 'View entries older than date'
   c.arg_name 'DATE_STRING'
@@ -1541,8 +1922,13 @@ command :view do |c|
   c.desc 'Only show items with recorded time intervals (override view settings)'
   c.switch [:only_timed], default_value: false, negatable: false
 
+  c.desc 'Select from a menu of matching entries to perform additional operations'
+  c.switch %i[i interactive]
+
   c.action do |_global_options, options, args|
-    exit_now! '--tag and --search cannot be used together' if options[:tag] && options[:search]
+    raise InvalidExportType, "Invalid export type: #{options[:output]}" if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise Doing::Errors::InvalidArgument, '--tag and --search can not be used together' if options[:tag] && options[:search]
 
     title = if args.empty?
               wwid.choose_view
@@ -1553,11 +1939,12 @@ command :view do |c|
     if options[:section]
       section = wwid.guess_section(options[:section]) || options[:section].cap_first
     else
-      section = wwid.config['current_section']
+      section = settings['current_section']
     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]
                      true
                    else
@@ -1565,7 +1952,7 @@ command :view do |c|
                    end
 
       template = view.key?('template') ? view['template'] : nil
-      format = view.key?('date_format') ? view['date_format'] : nil
+      date_format = view.key?('date_format') ? view['date_format'] : nil
       tags_color = view.key?('tags_color') ? view['tags_color'] : nil
       tag_filter = false
       if options[:tag]
@@ -1583,7 +1970,7 @@ command :view do |c|
       end
 
       # If the -o/--output flag was specified, override any default in the view template
-      options[:o] ||= view.key?('output_format') ? view['output_format'] : 'template'
+      options[:output] ||= view.key?('output_format') ? view['output_format'] : 'template'
 
       count = if options[:c]
                 options[:c]
@@ -1593,18 +1980,23 @@ command :view do |c|
       section = if options[:s]
                   section
                 else
-                  view.key?('section') ? view['section'] : wwid.current_section
+                  view.key?('section') ? view['section'] : settings['current_section']
                 end
-      order = view.key?('order') ? view['order'] : 'asc'
+      order = view.key?('order') ? view['order'].normalize_order : 'asc'
 
       totals = if options[:totals]
                  true
                else
                  view.key?('totals') ? view['totals'] : false
                end
+      tag_order = if options[:tag_order]
+                    options[:tag_order].normalize_order
+                  else
+                    view.key?('tag_order') ? view['tag_order'].normalize_order : 'asc'
+                  end
 
       options[:t] = true if totals
-      options[:output]&.downcase!
+      output_format = options[:output]&.downcase || 'template'
 
       options[:sort_tags] = if options[:tag_sort]
                               options[:tag_sort] =~ /^n/i ? true : false
@@ -1613,40 +2005,50 @@ command :view do |c|
                             else
                               false
                             end
+      if view.key?('after') && !options[:after]
+        options[:after] = view['after']
+      end
 
-      tag_order = if options[:tag_order]
-                    options[:tag_order] =~ /^d/i ? 'desc' : 'asc'
-                  elsif view.key?('tag_order')
-                    view['tag_order'] =~ /^d/i ? 'desc' : 'asc'
-                  else
-                    'asc'
-                  end
+      if view.key?('before') && !options[:before]
+        options[:before] = view['before']
+      end
 
-      opts = {
-        after: options[:after],
-        before: options[:before],
-        count: count,
-        format: format,
-        highlight: options[:color],
-        only_timed: only_timed,
-        order: order,
-        output: options[:output],
-        search: options[:search],
-        section: section,
-        sort_tags: options[:sort_tags],
-        tag_filter: tag_filter,
-        tag_order: tag_order,
-        tags_color: tags_color,
-        template: template,
-        times: options[:t],
-        totals: totals
-      }
+      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 Doing::Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
+        dates = [start, finish]
+      end
 
-      puts wwid.list_section(opts)
+      opts = options
+      opts[:output] = output_format
+      opts[:count] = count
+      opts[:format] = date_format
+      opts[:highlight] = options[:color]
+      opts[:only_timed] = only_timed
+      opts[:order] = order
+      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)
       exit_now! 'Cancelled'
     else
-      exit_now! "View #{title} not found in config"
+      raise Doing::Errors::InvalidView, "View #{title} not found in config"
     end
   end
 end
@@ -1663,9 +2065,18 @@ command :views do |c|
 end
 
 desc 'Move entries between sections'
-arg_name 'SECTION_NAME'
-default_value wwid.current_section
-command :archive do |c|
+long_desc %(Argument can be a section name to move all entries from a section,
+or start with an "@" to move entries matching a tag.
+
+Default with no argument moves items from the "#{settings['current_section']}" section to Archive.)
+arg_name 'SECTION_OR_TAG'
+default_value settings['current_section']
+command %i[archive move] do |c|
+  c.example 'doing archive Currently', desc: 'Move all entries in the Currently section to Archive section'
+  c.example 'doing archive @done', desc: 'Move all entries tagged @done to Archive'
+  c.example 'doing archive --to Later @project1', desc: 'Move all entries tagged @project1 to Later section'
+  c.example 'doing move Later --tag project1 --to Currently', desc: 'Move entries in Later tagged @project1 to Currently (move is an alias for archive)'
+
   c.desc 'How many items to keep (ignored if archiving by tag or search)'
   c.arg_name 'X'
   c.flag %i[k keep], must_match: /^\d+$/, type: Integer
@@ -1683,7 +2094,7 @@ command :archive do |c|
 
   c.desc 'Tag boolean (AND|OR|NOT)'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
 
   c.desc 'Search filter'
   c.arg_name 'QUERY'
@@ -1696,7 +2107,7 @@ command :archive do |c|
 
   c.action do |_global_options, options, args|
     if args.empty?
-      section = wwid.current_section
+      section = settings['current_section']
       tags = []
     elsif args[0] =~ /^all/i
       section = 'all'
@@ -1708,34 +2119,25 @@ command :archive do |c|
       tags = args.length > 1 ? args[1..].map { |t| t.sub(/^@/, '').strip } : []
     end
 
-    exit_now! '--keep and --count can\'t be used together' if options[:keep] && options[:count]
+    raise Doing::Errors::InvalidArgument, '--keep and --count can not be used together' if options[:keep] && options[:count]
 
-    tags.concat(options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if options[:tag]
+    tags.concat(options[:tag].to_tags) if options[:tag]
+
+    opts = options
+    opts[:bool] = options[:bool].normalize_bool
+    opts[:destination] = options[:to]
+    opts[:tags] = tags
 
-    options[:bool] = case options[:bool]
-                     when /(and|all)/i
-                      'AND'
-                     when /(any|or)/i
-                      'OR'
-                     when /(not|none)/i
-                      'NOT'
-                     else
-                      'AND'
-                     end
-    opts = {
-      before: options[:before],
-      bool: options[:bool],
-      destination: options[:to],
-      keep: options[:keep],
-      search: options[:search],
-      tags: tags
-    }
     wwid.archive(section, opts)
   end
 end
 
 desc 'Move entries to archive file'
 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'
+  c.example 'doing rotate --tag project1,done --bool AND', desc: 'Move entries tagged @project1 and @done to a secondary file'
+
   c.desc 'How many items to keep in each section (most recent)'
   c.arg_name 'X'
   c.flag %i[k keep], must_match: /^\d+$/, type: Integer
@@ -1750,7 +2152,7 @@ command :rotate do |c|
 
   c.desc 'Tag boolean (AND|OR|NOT)'
   c.arg_name 'BOOLEAN'
-  c.flag [:bool], must_match: /(?:and|all|any|or|not|none)/i, default_value: 'AND'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'AND'
 
   c.desc 'Search filter'
   c.arg_name 'QUERY'
@@ -1766,23 +2168,14 @@ command :rotate do |c|
       options[:section] = wwid.guess_section(options[:section])
     end
 
-    options[:bool] = case options[:bool]
-                     when /(and|all)/i
-                      'AND'
-                     when /(any|or)/i
-                      'OR'
-                     when /(not|none)/i
-                      'NOT'
-                     else
-                      'AND'
-                     end
+    options[:bool] = options[:bool].normalize_bool
 
     wwid.rotate(options)
   end
 end
 
 desc 'Open the "doing" file in an editor'
-long_desc "`doing open` defaults to using the editor_app setting in #{wwid.config_file} (#{wwid.config.key?('editor_app') ? wwid.config['editor_app'] : 'not set'})"
+long_desc "`doing open` defaults to using the editor_app setting in #{config.config_file} (#{settings.key?('editor_app') ? settings['editor_app'] : 'not set'})."
 command :open do |c|
   if `uname` =~ /Darwin/
     c.desc 'Open with app name'
@@ -1793,8 +2186,6 @@ command :open do |c|
     c.arg_name 'BUNDLE_ID'
     c.flag %i[b bundle_id]
   end
-  c.desc "Open with $EDITOR (#{ENV['EDITOR']})"
-  c.switch %i[e editor], negatable: false, default_value: false
 
   c.action do |_global_options, options, _args|
     params = options.dup
@@ -1806,30 +2197,54 @@ command :open do |c|
         system %(open -a "#{options[:a]}" "#{File.expand_path(wwid.doing_file)}")
       elsif options[:bundle_id]
         system %(open -b "#{options[:b]}" "#{File.expand_path(wwid.doing_file)}")
-      elsif options[:editor]
-        exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
-
-        system %($EDITOR "#{File.expand_path(wwid.doing_file)}")
-      elsif wwid.config.key?('editor_app') && !wwid.config['editor_app'].nil?
-        system %(open -a "#{wwid.config['editor_app']}" "#{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)
+          system %(#{editor} "#{File.expand_path(wwid.doing_file)}")
+        else
+          system %(open -a "#{editor}" "#{File.expand_path(wwid.doing_file)}")
+        end
       else
         system %(open "#{File.expand_path(wwid.doing_file)}")
       end
-
     else
-      exit_now! 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
-      system %($EDITOR "#{File.expand_path(wwid.doing_file)}")
+      system %(#{Doing::Util.default_editor} "#{File.expand_path(wwid.doing_file)}")
     end
   end
 end
 
-desc 'Edit the configuration file'
+desc 'Edit the configuration file or output a value from it'
+long_desc %(Run without arguments, `doing config` opens your `.doingrc` in an editor.
+If local configurations are found in the path between the current directory
+and `~/.doingrc`, a menu will allow you to select which to open in the editor.
+
+It will use the editor defined in `config_editor_app`, or one specified with `--editor`.
+
+Use `doing config -d` to output the configuration to the terminal, and
+provide a dot-separated key path to get a specific value. Shows the current value
+including keys/overrides set by local configs.)
+arg_name 'KEY_PATH'
 command :config do |c|
+  c.example 'doing config', desc: "Open an active configuration in #{Doing::Util.find_default_editor('config')}"
+  c.example 'doing config -d doing_file', desc: 'Output the value of a config key as YAML'
+  c.example 'doing config -d plugins.say.say_voice -o json', desc: 'Output the value of a key path as JSON'
+
   c.desc 'Editor to use'
   c.arg_name 'EDITOR'
   c.flag %i[e editor], default_value: nil
 
+  c.desc 'Show a config key value based on arguments. Separate key paths with colons or dots, e.g. "export_templates.html". Empty arguments outputs the entire config.'
+  c.switch %i[d dump]
+
+  c.desc 'Format for --dump (json|yaml|raw)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], default_value: 'yaml', must_match: /^(?:y(?:aml)?|j(?:son)?|r(?:aw)?)$/
+
+  c.desc 'Update config file with missing configuration options'
+  c.switch %i[u update], default_value: false, negatable: false
+
   if `uname` =~ /Darwin/
     c.desc 'Application to use'
     c.arg_name 'APP_NAME'
@@ -1839,31 +2254,84 @@ command :config do |c|
     c.arg_name 'BUNDLE_ID'
     c.flag [:b]
 
-    c.desc "Use the config_editor_app defined in ~/.doingrc (#{wwid.config.key?('config_editor_app') ? wwid.config['config_editor_app'] : 'config_editor_app not set'})"
+    c.desc "Use the config_editor_app defined in ~/.doingrc (#{settings.key?('config_editor_app') ? settings['config_editor_app'] : 'config_editor_app not set'})"
     c.switch [:x]
   end
 
-  c.action do |_global_options, options, _args|
+  c.action do |_global_options, options, args|
+    if options[:update]
+      config.configure({rewrite: true, ignore_local: true})
+      # Doing.logger.warn("Config file rewritten: #{config.config_file}")
+      return
+    end
+
+    if options[:dump]
+      keypath = args.join('.')
+      cfg = config.value_for_key(keypath)
+
+      if cfg
+        $stdout.puts case options[:output]
+                     when /^j/
+                       JSON.pretty_generate(cfg)
+                     when /^r/
+                       cfg
+                     else
+                       # cfg = { last_key => cfg } unless last_key.nil?
+                       YAML.dump(cfg)
+                     end
+      else
+        Doing.logger.log_now(:error, 'Config:', "Key #{keypath} not found")
+      end
+      Doing.logger.output_results
+      return
+    end
+
+    if config.additional_configs.count.positive?
+      choices = [config.config_file]
+      choices.concat(config.additional_configs)
+      res = wwid.choose_from(choices.uniq.sort.reverse, sorted: false, prompt: 'Local configs found, select which to edit > ')
+
+      raise Doing::Errors::UserCancelled, 'Cancelled' unless res
+
+      config_file = res.strip || config.config_file
+    else
+      config_file = config.config_file
+    end
+
     if `uname` =~ /Darwin/
       if options[:x]
-        `open -a "#{wwid.config['config_editor_app']}" "#{wwid.config_file}"`
+        editor = Doing::Util.find_default_editor('config')
+        if editor
+          if Doing::Util.exec_available(editor)
+            system %(#{editor} "#{config_file}")
+          else
+            `open -a "#{editor}" "#{config_file}"`
+          end
+        else
+          raise Doing::Errors::InvalidArgument, 'No viable editor found in config or environment.'
+        end
       elsif options[:a] || options[:b]
         if options[:a]
-          `open -a "#{options[:a]}" "#{wwid.config_file}"`
+          `open -a "#{options[:a]}" "#{config_file}"`
         elsif options[:b]
-          `open -b #{options[:b]} "#{wwid.config_file}"`
+          `open -b #{options[:b]} "#{config_file}"`
         end
       else
-        exit_now! 'No EDITOR variable defined in environment' if options[:e].nil? && ENV['EDITOR'].nil?
+        editor = options[:e] || Doing::Util.find_default_editor('config')
 
-        editor = options[:e].nil? ? ENV['EDITOR'] : options[:e]
-        system %(#{editor} "#{wwid.config_file}")
+        raise Doing::Errors::MissingEditor, 'No viable editor defined in config or environment' unless editor
+
+        if Doing::Util.exec_available(editor)
+          system %(#{editor} "#{config_file}")
+        else
+          `open -a "#{editor}" "#{config_file}"`
+        end
       end
     else
-      exit_now! 'No EDITOR variable defined in environment' if options[:e].nil? && ENV['EDITOR'].nil?
+      editor = options[:e] || Doing::Util.default_editor
+      raise Doing::Errors::MissingEditor, 'No EDITOR variable defined in environment' unless editor && Doing::Util.exec_available(editor)
 
-      editor = options[:e].nil? ? ENV['EDITOR'] : options[:e]
-      system %(#{editor} "#{wwid.config_file}")
+      system %(#{editor} "#{config_file}")
     end
   end
 end
@@ -1881,12 +2349,19 @@ command :undo do |c|
 end
 
 desc 'Import entries from an external source'
-long_desc 'Imports entries from other sources. Currently only handles JSON reports exported from Timing.app.'
+long_desc "Imports entries from other sources. Available plugins: #{Doing::Plugins.plugin_names(type: :import, separator: ', ')}"
 arg_name 'PATH'
 command :import do |c|
-  c.desc 'Import type'
+  c.desc "Import type (#{Doing::Plugins.plugin_names(type: :import)})"
   c.arg_name 'TYPE'
-  c.flag :type, default_value: 'timing'
+  c.flag :type, default_value: 'doing'
+
+  c.desc 'Only import items matching search. Surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  c.desc 'Only import items with recorded time intervals'
+  c.switch [:only_timed], default_value: false, negatable: false
 
   c.desc 'Target section'
   c.arg_name 'NAME'
@@ -1903,53 +2378,67 @@ command :import do |c|
   c.arg_name 'PREFIX'
   c.flag :prefix
 
+  c.desc 'Import entries older than date'
+  c.arg_name 'DATE_STRING'
+  c.flag [:before]
+
+  c.desc 'Import entries newer than date'
+  c.arg_name 'DATE_STRING'
+  c.flag [:after]
+
+  c.desc %(
+    Date range to import. Date range argument should be quoted. Date specifications can be natural language.
+    To specify a range, use "to" or "through": `--from "monday to friday"` or `--from 10/1 to 10/31`.
+    Has no effect unless the import plugin has implemented date range filtering.
+  )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag %i[f from]
+
   c.desc 'Allow entries that overlap existing times'
   c.switch [:overlap], negatable: true
 
   c.action do |_global_options, options, args|
 
     if options[:section]
-      section = wwid.guess_section(options[:section]) || options[:section].cap_first
-    else
-      section = wwid.config['current_section']
+      options[:section] = wwid.guess_section(options[:section]) || options[:section].cap_first
     end
 
-    if options[:type] =~ /^tim/i
-      args.each do |path|
-        options = {
-          autotag: options[:autotag],
-          no_overlap: !options[:overlap],
-          prefix: options[:prefix],
-          section: section,
-          tag: options[:tag]
-        }
-        wwid.import_timing(path, options)
-        wwid.write(wwid.doing_file)
+    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 Doing::Errors::InvalidTimeExpression, 'Unrecognized date string' unless start
+      dates = [start, finish]
+    end
+
+    if options[:type] =~ Doing::Plugins.plugin_regex(type: :import)
+      options[:no_overlap] = !options[:overlap]
+      options[:date_filter] = dates
+      wwid.import(args, options)
+      wwid.write(wwid.doing_file)
     else
-      exit_now! 'Invalid import type'
+      raise Doing::Errors::InvalidPluginType, "Invalid import type: #{options[:type]}"
     end
   end
 end
 
 pre do |global, _command, _options, _args|
-  if global[:config_file] && global[:config_file] != wwid.config_file
-    wwid.config_file = global[:config_file]
-    wwid.configure({ ignore_local: true })
-    # wwid.results.push("Override config file #{wwid.config_file}")
-  end
+  # global[:pager] ||= settings['paginate']
 
-  if global[:doing_file]
-    wwid.init_doing_file(global[:doing_file])
-  else
-    wwid.init_doing_file
-  end
-
-  wwid.auto_tag = !global[:noauto]
-
-  wwid.config[:include_notes] = false unless global[:notes]
+  Doing::Pager.paginate = global[:pager]
 
   $stdout.puts "doing v#{Doing::VERSION}" if global[:version]
+  unless STDOUT.isatty
+    Doing::Color::coloring = global[:pager] ? global[:color] : false
+  else
+    Doing::Color::coloring = global[:color]
+  end
 
   # Return true to proceed; false to abort and not call the
   # chosen command
@@ -1958,20 +2447,57 @@ pre do |global, _command, _options, _args|
   true
 end
 
+on_error do |exception|
+  # if exception.kind_of?(SystemExit)
+  #   false
+  # else
+  #   p exception.inspect
+  #   Doing.logger.output_results
+  #   true
+  # end
+  false
+end
+
 post do |global, _command, _options, _args|
   # Use skips_post before a command to skip this
   # block on that command only
+  Doing.logger.output_results
+end
+
+around do |global, command, options, arguments, code|
+  # Doing.logger.debug('Pager:', "Global: #{global[:pager]}, Config: #{settings['paginate']}, Pager: #{Doing::Pager.paginate}")
+  Doing.logger.adjust_verbosity(global)
 
   if global[:stdout]
-    $stdout.print wwid.results.join("\n")
+    Doing.logger.logdev = $stdout
+  end
+
+  wwid.default_option = global[:default]
+
+  if global[:config_file] && global[:config_file] != config.config_file
+    Doing.logger.warn(format('%sWARNING:%s %sThe use of --config_file is deprecated, please set the environment variable DOING_CONFIG instead.', colors.flamingo, colors.default, colors.boldred))
+    Doing.logger.warn(format('%sTo set it just for the current command, use: %sDOING_CONFIG=/path/to/doingrc doing [command]%s',  colors.red, colors.boldwhite, colors.default))
+
+    cf = File.expand_path(global[:config_file])
+    raise MissingConfigFile, "Config file not found (#{global[:config_file]})" unless File.exist?(cf)
+
+    config.config_file = cf
+    settings = config.configure({ ignore_local: true })
+  end
+
+  if global[:doing_file]
+    wwid.init_doing_file(global[:doing_file])
   else
-    warn wwid.results.join("\n")
+    wwid.init_doing_file
   end
-end
 
-on_error do |_exception|
-  # puts exception.message
-  true
+  wwid.auto_tag = !global[:noauto]
+
+  settings[:include_notes] = false unless global[:notes]
+
+  global[:wwid] = wwid
+
+  code.call
 end
 
 exit run(ARGV)