doing 2.1.25 → 2.1.26

data/bin/commands/note.rb

@@ -0,0 +1,130 @@
+# @@note
+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.
+
+  Use -e to load the last entry in a text editor where you can append a note.
+)
+arg_name 'NOTE_TEXT', optional: true
+command :note do |c|
+  c.example 'doing note', desc: 'Open the last entry in $EDITOR to append a note'
+  c.example 'doing note "Just a quick annotation"', desc: 'Add a quick note to the last entry'
+  c.example 'doing note --tag done "Keeping it real or something"', desc: 'Add a note to the last item tagged @done'
+  c.example 'doing note --search "late night" -e', desc: 'Open $EDITOR to add a note to the last item containing "late night" (fuzzy matched)'
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  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. Wildcards allowed (*, ?)'
+  c.arg_name 'TAG'
+  c.flag [:tag], type: TagArray
+
+  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 'Perform a tag value query ("@done > two hours ago" or "@progress < 50"). May be used multiple times, combined with --bool'
+  c.arg_name 'QUERY'
+  c.flag [:val], multiple: true, must_match: REGEX_VALUE_QUERY
+
+  # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
+  # c.switch [:fuzzy], default_value: false, negatable: false
+
+  c.desc 'Force exact search string matching (case sensitive)'
+  c.switch %i[x exact], default_value: @config.exact_match?, negatable: @config.exact_match?
+
+  c.desc 'Add note to item that *doesn\'t* match search/tag filters'
+  c.switch [:not], default_value: false, negatable: false
+
+  c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
+  c.arg_name 'TYPE'
+  c.flag [:case], must_match: /^[csi]/, default_value: @settings.dig('search', 'case')
+
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
+
+  c.desc 'Select item for new note from a menu of matching entries'
+  c.switch %i[i interactive], negatable: false, default_value: false
+
+  c.desc 'Prompt for note via multi-line input'
+  c.switch %i[ask], negatable: false, default_value: false
+
+  c.action do |_global_options, options, args|
+    options[:fuzzy] = false
+    if options[:section]
+      options[:section] = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    options[:tag_bool] = options[:bool].normalize_bool
+
+    options[:case] = options[:case].normalize_case
+
+    if options[:search]
+      search = options[:search]
+      search.sub!(/^'?/, "'") if options[:exact]
+      options[:search] = search
+    end
+
+    last_entry = @wwid.last_entry(options)
+    old_entry = last_entry.clone
+
+    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 $stdin.stat.size.positive?
+      new_note.add($stdin.read.strip)
+    end
+
+    unless args.empty?
+      new_note.add(args.join(' '))
+    end
+
+    if options[:editor]
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+
+      if options[:remove]
+        input = Doing::Note.new
+      else
+        input = last_entry.note || Doing::Note.new
+      end
+
+      input.add(new_note)
+
+      new_note = Doing::Note.new(@wwid.fork_editor(input.strip_lines.join("\n"), message: nil).strip)
+      options[:remove] = true
+    end
+
+    if (new_note.empty? && !options[:remove]) || options[:ask]
+      $stderr.puts last_note if last_note.good?
+      $stderr.puts new_note if new_note.good?
+      new_note.add(Doing::Prompt.read_lines(prompt: 'Add a note'))
+    end
+
+    raise EmptyInput, 'You must provide content when adding a note' unless options[:remove] || new_note.good?
+
+    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)
+      Doing::Hooks.trigger :post_entry_updated, @wwid, last_entry, old_entry
+    end
+    # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
+    @wwid.write(@wwid.doing_file)
+  end
+end

data/bin/commands/now.rb

@@ -0,0 +1,151 @@
+# @@now @@next
+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 without arguments to create a new entry interactively.
+
+Run with --editor to create a new entry using #{Doing::Util.default_editor}.)
+arg_name 'ENTRY'
+command %i[now next] do |c|
+  c.example 'doing now', desc: 'Create a new entry with interactive prompts'
+  c.example 'doing now -e', 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 #{Doing::Util.default_editor}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc 'Backdate start time [4pm|20m|2h|"yesterday noon"]'
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back started], type: DateBeginString
+
+  c.desc %(
+        Set a start and optionally end time as a date range ("from 1pm to 2:30pm").
+        If an end time is provided, a dated @done tag will be added
+      )
+  c.arg_name 'TIME_RANGE'
+  c.flag [:from], type: DateRangeString
+
+  c.desc 'Timed entry, marks last entry in section as @done'
+  c.switch %i[f finish_last], negatable: false, default_value: false
+
+  c.desc 'Include a note'
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
+
+  c.desc 'Prompt for note via multi-line input'
+  c.switch %i[ask], negatable: false, default_value: false
+
+  # c.desc "Edit entry with specified app"
+  # c.arg_name 'editor_app'
+  # # c.flag [:a, :app]
+
+  c.action do |_global_options, options, args|
+    raise InvalidArgument, "--back and --from cannot be used together" if options[:back] && options[:from]
+
+    if options[:back]
+      date = options[:back]
+    elsif options[:from]
+      date, finish_date = options[:from]
+      options[:done] = finish_date
+    else
+      date = Time.now
+    end
+    raise InvalidTimeExpression.new('unable to parse date string', topic: 'Parser:') if date.nil?
+
+    if options[:section]
+      section = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    else
+      options[:section] = @settings['current_section']
+    end
+
+    ask_note = options[:ask] && !options[:editor] && args.count.positive? ? Doing::Prompt.read_lines(prompt: 'Add a note') : ''
+
+    if options[:editor]
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+
+      input = date.strftime('%F %R | ')
+      input += args.join(' ') unless args.empty?
+      input += " @done(#{options[:done].strftime('%F %R')})" if options[:done]
+      input += "\n#{options[:note]}" if options[:note]
+      input += "\n#{ask_note}" if ask_note.good?
+      input = @wwid.fork_editor(input).strip
+
+      d, title, note = @wwid.format_input(input)
+      raise EmptyInput, 'No content' unless title.good?
+
+      if ask_note.empty? && options[:ask]
+        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
+        note.add(ask_note) if ask_note.good?
+      end
+
+      date = d.nil? ? date : d
+      @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      @wwid.write(@wwid.doing_file)
+    elsif args.length.positive?
+      d, title, note = @wwid.format_input(args.join(' '))
+      date = d.nil? ? date : d
+      note.add(options[:note]) if options[:note]
+      note.add(ask_note) if ask_note.good?
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    elsif $stdin.stat.size.positive?
+      input = $stdin.read.strip
+      d, title, note = @wwid.format_input(input)
+      unless d.nil?
+        Doing.logger.debug('Parser:', 'Date detected in input, overriding command line values')
+        date = d
+      end
+      note.add(options[:note]) if options[:note]
+      if ask_note.empty? && options[:ask]
+        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
+        note.add(ask_note) if ask_note.good?
+      end
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    else
+      tags = @wwid.all_tags(@wwid.content)
+      $stderr.puts Doing::Color.boldgreen("Add a new entry. Tab will autocomplete known tags. Ctrl-c to cancel.")
+      title = Doing::Prompt.read_line(prompt: 'Entry content', completions: tags)
+      raise EmptyInput, 'You must provide content when creating a new entry' unless title.good?
+
+      note = Doing::Note.new
+      note.add(options[:note]) if options[:note]
+      res = Doing::Prompt.yn('Add a note', default_response: false)
+      ask_note = res ? Doing::Prompt.read_lines(prompt: 'Enter note') : []
+      note.add(ask_note)
+
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    end
+  end
+end

data/bin/commands/on.rb

@@ -0,0 +1,66 @@
+# @@on
+desc 'List entries for a date'
+long_desc %(Date argument can be natural language. "thursday" would be interpreted as "last thursday,"
+and "2d" would be interpreted as "two days ago." If you use "to" or "through" between two dates,
+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'
+
+  c.desc 'Show time intervals on @done tasks'
+  c.switch %i[t times], default_value: true, negatable: true
+
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
+  c.desc 'Show time totals at the end of output'
+  c.switch [:totals], default_value: false, negatable: false
+
+  c.desc 'Sort tags by (name|time)'
+  default = 'time'
+  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 (#{Doing::Plugins.plugin_names(type: :export)})"
+  c.arg_name 'FORMAT'
+  c.flag %i[o output]
+
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'default'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
+  c.action do |_global_options, options, args|
+    raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise MissingArgument, 'Missing date argument' if args.empty?
+
+    date_string = args.join(' ').strip
+    if date_string =~ /^tod(?:ay)?/i
+      date_string = 'today to tomorrow 12am'
+    end
+    start, finish = date_string.split_date_range
+
+    raise InvalidTimeExpression, 'Unrecognized date string' unless start
+
+    message = "date interpreted as #{start}"
+    message += " to #{finish}" if finish
+    Doing.logger.debug('Interpreter:', message)
+
+    options[:times] = true if options[:totals]
+    options[:sort_tags] = options[:tag_sort] =~ /^n/i
+
+    Doing::Pager.page @wwid.list_date([start, finish], options[:section], options[:times], options[:output],
+                        { template: options[:template], config_template: options[:config_template], duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+  end
+end

data/bin/commands/open.rb

@@ -0,0 +1,53 @@
+# @@open
+desc 'Open the "doing" file in an editor'
+long_desc "`doing open` defaults to using the editors->doing_file setting
+in #{@config.config_file} (#{Doing::Util.find_default_editor('doing_file')})."
+command :open do |c|
+  c.example 'doing open', desc: 'Open the doing file in the default editor'
+  c.desc 'Open with editor command (e.g. vim, mate)'
+  c.arg_name 'COMMAND'
+  c.flag %i[e editor]
+
+  if `uname` =~ /Darwin/
+    c.desc 'Open with app name'
+    c.arg_name 'APP_NAME'
+    c.flag %i[a app]
+
+    c.desc 'Open with app bundle id'
+    c.arg_name 'BUNDLE_ID'
+    c.flag %i[b bundle_id]
+  end
+
+  c.action do |_global_options, options, _args|
+    params = options.clone
+    params.delete_if do |k, v|
+      k.instance_of?(String) || v.nil? || v == false
+    end
+
+    if options[:editor]
+      raise MissingEditor, "Editor #{options[:editor]} not found" unless Doing::Util.exec_available(options[:editor].split(/ /).first)
+
+      editor = TTY::Which.which(options[:editor])
+      system %(#{editor} "#{File.expand_path(@wwid.doing_file)}")
+    elsif `uname` =~ /Darwin/
+      if options[:app]
+        system %(open -a "#{options[:app]}" "#{File.expand_path(@wwid.doing_file)}")
+      elsif options[:bundle_id]
+        system %(open -b "#{options[:bundle_id]}" "#{File.expand_path(@wwid.doing_file)}")
+      elsif Doing::Util.find_default_editor('doing_file')
+        editor = Doing::Util.find_default_editor('doing_file')
+        if Doing::Util.exec_available(editor.split(/ /).first)
+          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
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+
+      system %(#{Doing::Util.default_editor} "#{File.expand_path(@wwid.doing_file)}")
+    end
+  end
+end

data/bin/commands/plugins.rb

@@ -0,0 +1,23 @@
+# @@plugins
+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], negatable: false, default_value: false
+
+  c.action do |_global_options, options, _args|
+    Doing::Plugins.list_plugins(options)
+  end
+end

data/bin/commands/recent.rb

@@ -0,0 +1,78 @@
+# @@recent
+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'
+
+  c.desc 'Show time intervals on @done tasks'
+  c.switch %i[t times], default_value: true, negatable: true
+
+  c.desc "Output using a template from configuration"
+  c.arg_name 'TEMPLATE_KEY'
+  c.flag [:config_template], type: TemplateName, default_value: 'recent'
+
+  c.desc 'Override output format with a template string containing %placeholders'
+  c.arg_name 'TEMPLATE_STRING'
+  c.flag [:template]
+
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
+  c.desc 'Show intervals with totals at the end of output'
+  c.switch [:totals], default_value: false, negatable: false
+
+  c.desc 'Sort tags by (name|time)'
+  default = 'time'
+  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], negatable: false, default_value: false
+
+  c.action do |global_options, options, args|
+    section = @wwid.guess_section(options[:section]) || options[:section].cap_first
+
+    unless global_options[:version]
+      if @settings['templates']['recent'].key?('count')
+        config_count = @settings['templates']['recent']['count'].to_i
+      else
+        config_count = 10
+      end
+
+      if options[:interactive]
+        count = 0
+      else
+        count = args.empty? ? config_count : args[0].to_i
+      end
+
+      options[:times] = true if options[:totals]
+      options[:sort_tags] = options[:tag_sort] =~ /^n/i
+
+      template = @settings['templates']['recent'].deep_merge(@settings['templates']['default'])
+      tags_color = template.key?('tags_color') ? template['tags_color'] : nil
+
+      opts = {
+        sort_tags: options[:sort_tags],
+        tags_color: tags_color,
+        times: options[:times],
+        totals: options[:totals],
+        interactive: options[:interactive],
+        duration: options[:duration],
+        config_template: options[:config_template],
+        template: options[:template]
+      }
+
+      Doing::Pager::page @wwid.recent(count, section.cap_first, opts)
+
+    end
+  end
+end

data/bin/commands/redo.rb

@@ -0,0 +1,22 @@
+# @@redo
+long_desc 'Shortcut for `doing undo -r`, reverses the last undo command. You cannot undo a redo'
+arg_name 'COUNT'
+command :redo do |c|
+  c.desc 'Specify alternate doing file'
+  c.arg_name 'PATH'
+  c.flag %i[f file], default_value: @wwid.doing_file
+
+  c.desc 'Select from an interactive menu'
+  c.switch %i[i interactive]
+
+  c.action do |_global, options, args|
+    file = options[:file] || @wwid.doing_file
+    count = args.empty? ? 1 : args[0].to_i
+    raise InvalidArgument, "Invalid count specified for redo" unless count&.positive?
+    if options[:interactive]
+      Doing::Util::Backup.select_redo(file)
+    else
+      Doing::Util::Backup.redo_backup(file, count: count)
+    end
+  end
+end

data/bin/commands/reset.rb

@@ -0,0 +1,106 @@
+# @@reset @@begin
+desc 'Reset the start time of an entry'
+long_desc 'Update the start time of the last entry or the last entry matching a tag/search filter.
+If no argument is provided, the start time will be reset to the current time.
+If a date string is provided as an argument, the start time will be set to the parsed result.'
+arg_name 'DATE_STRING', optional: true
+command %i[reset begin] do |c|
+  c.example 'doing reset', desc: 'Reset the start time of the last entry to the current time'
+  c.example 'doing reset --tag project1', desc: 'Reset the start time of the most recent entry tagged @project1 to the current time'
+  c.example 'doing reset 3pm', desc: 'Reset the start time of the last entry to 3pm of the current day'
+  c.example 'doing begin --tag todo --resume', desc: 'alias for reset. Updates the last @todo entry to the current time, removing @done tag.'
+
+  c.desc 'Limit search to section'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc 'Resume entry (remove @done)'
+  c.switch %i[r resume], default_value: true
+
+  c.desc 'Change start date but do not remove @done (shortcut for --no-resume)'
+  c.switch [:n]
+
+  c.desc 'Reset last entry matching tag. Wildcards allowed (*, ?)'
+  c.arg_name 'TAG'
+  c.flag [:tag]
+
+  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 'Perform a tag value query ("@done > two hours ago" or "@progress < 50"). May be used multiple times, combined with --bool'
+  c.arg_name 'QUERY'
+  c.flag [:val], multiple: true, must_match: REGEX_VALUE_QUERY
+
+  # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
+  # c.switch [:fuzzy], default_value: false, negatable: false
+
+  c.desc 'Force exact search string matching (case sensitive)'
+  c.switch %i[x exact], default_value: @config.exact_match?, negatable: @config.exact_match?
+
+  c.desc 'Reset items that *don\'t* match search/tag filters'
+  c.switch [:not], default_value: false, negatable: false
+
+  c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
+  c.arg_name 'TYPE'
+  c.flag [:case], must_match: /^[csi]/, default_value: @settings.dig('search', 'case')
+
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
+
+  c.desc 'Select from a menu of matching entries'
+  c.switch %i[i interactive], negatable: false, default_value: false
+
+  c.action do |global_options, options, args|
+    if args.count > 0
+      reset_date = args.join(' ').chronify(guess: :begin)
+      raise InvalidArgument, 'Invalid date string' unless reset_date
+    else
+      reset_date = Time.now
+    end
+
+    options[:fuzzy] = false
+    if options[:section]
+      options[:section] = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    options[:bool] = options[:bool].normalize_bool
+
+    options[:case] = options[:case].normalize_case
+
+    if options[:search]
+      search = options[:search]
+      search.sub!(/^'?/, "'") if options[:exact]
+      options[:search] = search
+    end
+
+
+    items = @wwid.filter_items([], opt: options)
+
+    if options[:interactive]
+      last_entry = Doing::Prompt.choose_from_items(items, include_section: options[:section].nil?,
+        menu: true,
+        header: '',
+        prompt: 'Select an entry to start/reset > ',
+        multiple: false,
+        sort: false,
+        show_if_single: true)
+    else
+      last_entry = items.reverse.last
+    end
+
+    unless last_entry
+      Doing.logger.warn('Not found:', 'No entry matching parameters was found.')
+      return
+    end
+
+    old_item = last_entry.clone
+
+    @wwid.reset_item(last_entry, date: reset_date, resume: options[:resume])
+    Doing::Hooks.trigger :post_entry_updated, @wwid, last_entry, old_item
+    # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
+
+    @wwid.write(@wwid.doing_file)
+  end
+end