na 1.1.25 → 1.2.0

data/lib/na/next_action.rb

@@ -89,6 +89,7 @@ module NA
         ENDCONTENT
         f.puts(content)
       end
+      save_working_dir(target)
       notify("{y}Created {bw}#{target}")
     end
 
@@ -106,24 +107,28 @@ module NA
     ##
     ## Select from multiple files
     ##
-    ## @note If `gum` or `fzf` are available, they'll be used (in that order)
+    ## @note       If `gum` or `fzf` are available, they'll
+    ##             be used (in that order)
     ##
-    ## @param      files  [Array] The files
+    ## @param      files     [Array] The files
+    ## @param      multiple  [Boolean] allow multiple selections
     ##
-    def select_file(files)
-      if TTY::Which.exist?('gum')
-        args = [
-          '--cursor.foreground="151"',
-          '--item.foreground=""'
-        ]
-        `echo #{Shellwords.escape(files.join("\n"))}|#{TTY::Which.which('gum')} choose #{args.join(' ')}`.strip
-      elsif TTY::Which.exist?('fzf')
-        res = choose_from(files, prompt: 'Use which file?')
+    def select_file(files, multiple: false)
+      if TTY::Which.exist?('fzf')
+        res = choose_from(files, prompt: 'Use which file?', multiple: multiple)
         unless res
           notify('{r}No file selected, cancelled', exit_code: 1)
         end
 
-        res.strip
+        multiple ? res.split("\n") : res.strip
+      elsif TTY::Which.exist?('gum')
+        args = [
+          '--cursor.foreground="151"',
+          '--item.foreground=""'
+        ]
+        args.push('--no-limit') if multiple
+        res = `echo #{Shellwords.escape(files.join("\n"))}|#{TTY::Which.which('gum')} choose #{args.join(' ')}`
+        multiple ? res.split("\n") : res.strip
       else
         reader = TTY::Reader.new
         puts
@@ -135,6 +140,195 @@ module NA
       end
     end
 
+    def shift_index_after(projects, idx, length = 1)
+      projects.map do |proj|
+        proj.line = proj.line > idx ? proj.line - length : proj.line
+        proj
+      end
+    end
+
+    def find_projects(target)
+      _, _, projects = parse_actions(require_na: false, file_path: target)
+      projects
+    end
+
+    def find_actions(target, search, tagged = nil, all: false)
+      _, actions, projects = parse_actions(search: search, require_na: false, file_path: target, tag: tagged)
+
+      NA.notify('{r}No matching actions found', exit_code: 1) unless actions.count.positive?
+      return [projects, actions] if actions.count == 1 || all
+
+      options = actions.map { |action| "#{action.line} % #{action.parent.join('/')} : #{action.action}" }
+      res = if TTY::Which.exist?('fzf')
+              choose_from(options, prompt: 'Make a selection: ', multiple: true, sorted: true)
+            elsif TTY::Which.exist?('gum')
+              args = [
+                '--cursor.foreground="151"',
+                '--item.foreground=""',
+                '--no-limit'
+              ]
+              `echo #{Shellwords.escape(options.join("\n"))}|#{TTY::Which.which('gum')} choose #{args.join(' ')}`.strip
+            else
+              reader = TTY::Reader.new
+              puts
+              options.each.with_index do |f, i|
+                puts NA::Color.template(format("{bw}%<idx> 2d{xw}) {y}%<action>s{x}\n", idx: i + 1, action: f))
+              end
+              result = reader.read_line(NA::Color.template('{bw}Use which file? {x}')).strip
+              if result && result.to_i.positive?
+                options[result.to_i - 1]
+              else
+                nil
+              end
+            end
+
+      NA.notify('{r}Cancelled', exit_code: 1) unless res && res.length.positive?
+
+      selected = []
+      res.split(/\n/).each do |result|
+        idx = result.match(/^(\d+)(?= % )/)[1]
+        action = actions.select { |a| a.line == idx.to_i }.first
+        selected.push(action)
+      end
+      [projects, selected]
+    end
+
+    def insert_project(target, project)
+      path = project.split(%r{[:/]})
+      _, _, projects = parse_actions(file_path: target)
+      built = []
+      last_match = nil
+      final_match = nil
+      new_path = []
+      matches = nil
+      path.each_with_index do |part, i|
+        built.push(part)
+        matches = projects.select { |proj| proj.project =~ /^#{built.join(':')}/i }
+        if matches.count.zero?
+          final_match = last_match
+          new_path = path.slice(i, path.count - i)
+          break
+        else
+          last_match = matches.last
+        end
+      end
+
+      content = target.read_file
+      if final_match.nil?
+        indent = 0
+        input = []
+        new_path.each do |part|
+          input.push("#{"\t" * indent}#{part.cap_first}:")
+          indent += 1
+        end
+
+        if new_path.join('') =~ /Archive/i
+          content = "#{content.strip}\n#{input.join("\n")}"
+        else
+          content = "#{input.join("\n")}\n#{content}"
+        end
+
+        new_project = NA::Project.new(path.map(&:cap_first).join(':'), indent - 1, input.count - 1)
+      else
+        line = final_match.line + 1
+        indent = final_match.indent + 1
+        input = []
+        new_path.each do |part|
+          input.push("#{"\t" * indent}#{part.cap_first}:")
+          indent += 1
+        end
+        content = content.split("\n").insert(line, input.join("\n")).join("\n")
+        new_project = NA::Project.new(path.map(&:cap_first).join(':'), indent - 1, line + input.count - 1)
+      end
+
+      File.open(target, 'w') do |f|
+        f.puts content
+      end
+
+      new_project
+    end
+
+    def update_action(target,
+                      search,
+                      priority: 0,
+                      add_tag: [],
+                      remove_tag: [],
+                      finish: false,
+                      project: nil,
+                      delete: false,
+                      note: [],
+                      overwrite: false,
+                      tagged: nil,
+                      all: false)
+
+      projects = find_projects(target)
+
+      target_proj = nil
+
+      if project
+        target_proj = projects.select { |pr| pr.project =~ /#{project.gsub(/:/, '.*?:.*?')}/i }.first
+        if target_proj.nil?
+          res = NA.yn(NA::Color.template("{y}Project {bw}#{project}{xy} doesn't exist, add it"), default: true)
+          if res
+            target_proj = insert_project(target, project)
+          else
+            NA.notify('{x}Cancelled', exit_code: 1)
+          end
+        end
+      end
+
+      projects, actions = find_actions(target, search, tagged, all: all)
+
+      contents = target.read_file.split(/\n/)
+
+      actions.sort_by(&:line).reverse.each do |action|
+        string = action.action
+
+        if priority&.positive?
+          string.gsub!(/@priority\(\d+\)/, '').strip!
+          string += " @priority(#{priority})"
+        end
+
+        add_tag.each do |tag|
+          string.gsub!(/@#{tag.gsub(/([()*?])/, '\\\\1')}(\(.*?\))?/, '')
+          string.strip!
+          string += " @#{tag}"
+        end
+
+        remove_tag.each do |tag|
+          string.gsub!(/@#{tag}(\(.*?\))?/, '')
+          string.strip!
+        end
+
+        string = "#{string.strip} @done(#{Time.now.strftime('%Y-%m-%d %H:%M')})" if finish && string !~ /@done/
+
+        contents.slice!(action.line, action.note.count + 1)
+        next if delete
+
+        projects = shift_index_after(projects, action.line, action.note.count + 1)
+
+        target_proj = if target_proj
+                        projects.select { |proj| proj.project =~ /^#{target_proj.project}$/ }.first
+                      else
+                        projects.select { |proj| proj.project =~ /^#{action.parent.join(':')}$/ }.first
+                      end
+
+        indent = "\t" * target_proj.indent
+        note = note.split("\n") unless note.is_a?(Array)
+        note = if note.empty?
+                 action.note
+               else
+                 overwrite ? note : action.note.concat(note)
+               end
+        note = note.empty? ? '' : "\n#{indent}\t\t#{note.join("\n#{indent}\t\t").strip}"
+        contents.insert(target_proj.line, "#{indent}\t- #{string}#{note}")
+      end
+      backup_file(target)
+      File.open(target, 'w') { |f| f.puts contents.join("\n") }
+
+      notify("{by}Task updated in {bw}#{target}")
+    end
+
     ##
     ## Add an action to a todo file
     ##
@@ -153,7 +347,8 @@ module NA
       # Insert the action at the top of the target project
       content.sub!(/^([ \t]*)#{project}:(.*?)$/i) do
         m = Regexp.last_match
-        note = note.nil? ? '' : "\n#{m[1]}\t\t#{note.join('').strip}"
+        indent = "\n#{m[1]}\t\t"
+        note = note.nil? ? '' : "#{indent}#{note.join(indent).strip}"
         "#{m[1]}#{project.cap_first}:#{m[2]}\n#{m[1]}\t- #{action}#{note}"
       end
 
@@ -197,16 +392,19 @@ module NA
     ##
     ## Read a todo file and create a list of actions
     ##
-    ## @param      depth       [Number] The directory depth to search for files
-    ## @param      query       [Hash] The project query
-    ## @param      tag         [Hash] Tags to search for
+    ## @param      depth       [Number] The directory depth
+    ##                         to search for files
+    ## @param      query       [Hash] The todo file query
+    ## @param      tag         [Array] Tags to search for
     ## @param      search      [String] A search string
     ## @param      negate      [Boolean] Invert results
-    ## @param      regex       [Boolean] Interpret as regular expression
+    ## @param      regex       [Boolean] Interpret as
+    ##                         regular expression
     ## @param      project     [String] The project
     ## @param      require_na  [Boolean] Require @na tag
+    ## @param      file        [String] file path to parse
     ##
-    def parse_actions(depth: 1, query: nil, tag: nil, search: nil, negate: false, regex: false, project: nil, require_na: true)
+    def parse_actions(depth: 1, query: nil, tag: nil, search: nil, negate: false, regex: false, project: nil, require_na: true, file_path: nil)
       actions = []
       required = []
       optional = []
@@ -214,6 +412,7 @@ module NA
       required_tag = []
       optional_tag = []
       negated_tag = []
+      projects = []
 
       tag&.each do |t|
         unless t[:tag].nil?
@@ -247,7 +446,9 @@ module NA
         end
       end
 
-      files = if query.nil?
+      files = if !file_path.nil?
+                [file_path]
+              elsif query.nil?
                 find_files(depth: depth)
               else
                 match_working_dir(query)
@@ -258,8 +459,10 @@ module NA
         content = file.read_file
         indent_level = 0
         parent = []
-        content.split("\n").each do |line|
-          if line =~ /([ \t]*)([^\-]+.*?): *(@\S+ *)*$/
+        in_action = false
+        content.split("\n").each.with_index do |line, idx|
+          if line =~ /^([ \t]*)([^\-@()]+?): *(@\S+ *)*$/
+            in_action = false
             proj = Regexp.last_match(2)
             indent = line.indent_level
 
@@ -272,14 +475,22 @@ module NA
               parent.push(proj)
             end
 
+            projects.push(NA::Project.new(parent.join(':'), indent, idx + 1))
+
             indent_level = indent
-          elsif line =~ /^[ \t]*- / && line !~ / @done/
+          elsif line =~ /^[ \t]*- /
+            in_action = false
+            # search_for_done = false
+            # optional_tag.each { |t| search_for_done = true if t[:tag] =~ /done/ }
+            # next if line =~ /@done/ && !search_for_done
+
             next if require_na && line !~ /@#{NA.na_tag}\b/
 
             action = line.sub(/^[ \t]*- /, '')
-            new_action = NA::Action.new(file, File.basename(file, ".#{NA.extension}"), parent.dup, action)
+            new_action = NA::Action.new(file, File.basename(file, ".#{NA.extension}"), parent.dup, action, idx)
 
             has_search = !optional.empty? || !required.empty? || !negated.empty?
+
             next if has_search && !new_action.search_match?(any: optional,
                                                             all: required,
                                                             none: negated)
@@ -295,10 +506,14 @@ module NA
                                                        none: negated_tag)
 
             actions.push(new_action)
+            in_action = true
+          else
+            actions[-1].note.push(line.strip) if actions.count.positive? && in_action
           end
         end
       end
-      [files, actions]
+
+      [files, actions, projects]
     end
 
     def edit_file(file: nil, app: nil)
@@ -336,9 +551,32 @@ module NA
       end
     end
 
+    def list_projects(query: [], file_path: nil, depth: 1, paths: true)
+      files = if !file_path.nil?
+                [file_path]
+              elsif query.nil?
+                find_files(depth: depth)
+              else
+                match_working_dir(query)
+              end
+      target = files.count > 1 ? NA.select_file(files) : files[0]
+      projects = find_projects(target)
+      projects.each do |proj|
+        parts = proj.project.split(/:/)
+        output = if paths
+                   "{bg}#{parts.join('{bw}/{bg}')}{x}"
+                 else
+                   parts.fill("{bw}—{bg}", 0..-2)
+                   "{bg}#{parts.join(' ')}{x}"
+                 end
+
+        puts NA::Color.template(output)
+      end
+    end
+
     def list_todos(query: [])
       if query
-        dirs = match_working_dir(query)
+        dirs = match_working_dir(query, distance: 2, require_last: false)
       else
         file = database_path
         content = File.exist?(file) ? file.read_file.strip : ''
@@ -386,6 +624,40 @@ module NA
       searches
     end
 
+    def delete_search(strings = nil)
+      NA.notify('{r}Name search required', exit_code: 1) if strings.nil? || strings.empty?
+
+      file = database_path(file: 'saved_searches.yml')
+      NA.notify('{r}No search definitions file found', exit_code: 1) unless File.exist?(file)
+
+      searches = YAML.safe_load(file.read_file)
+      keys = searches.keys.delete_if { |k| k !~ /(#{strings.join('|')})/ }
+
+      res = yn(NA::Color.template(%({y}Remove #{keys.count > 1 ? 'searches' : 'search'} {bw}"#{keys.join(', ')}"{x})),
+               default: false)
+
+      NA.notify('{r}Cancelled', exit_code: 1) unless res
+
+      searches.delete_if { |k| keys.include?(k) }
+
+      File.open(file, 'w') { |f| f.puts(YAML.dump(searches)) }
+
+      NA.notify("{y}Deleted {bw}#{keys.count}{xy} #{keys.count > 1 ? 'searches' : 'search'}", exit_code: 0)
+    end
+
+    def edit_searches
+      file = database_path(file: 'saved_searches.yml')
+      searches = load_searches
+
+      NA.notify('{r}No search definitions found', exit_code: 1) unless searches.count.positive?
+
+      editor = ENV['EDITOR']
+      NA.notify('{r}No $EDITOR defined', exit_code: 1) unless editor && TTY::Which.exist?(editor)
+
+      system %(#{editor} "#{file}")
+      NA.notify("Opened #{file} in #{editor}", exit_code: 0)
+    end
+
     ##
     ## Get path to database of known todo files
     ##
@@ -398,6 +670,58 @@ module NA
       File.join(db_dir, file)
     end
 
+    ##
+    ## Create a backup file
+    ##
+    ## @param      target [String] The file to back up
+    ##
+    def backup_file(target)
+      FileUtils.cp(target, "#{target}~")
+    end
+
+    ##
+    ## Find a matching path using semi-fuzzy matching.
+    ## Search tokens can include ! and + to negate or make
+    ## required.
+    ##
+    ## @param      search        [Array] search tokens to
+    ##                           match
+    ## @param      distance      [Integer] allowed distance
+    ##                           between characters
+    ## @param      require_last  [Boolean] require regex to
+    ##                           match last element of path
+    ##
+    ## @return     [Array] array of matching directories/todo files
+    ##
+    def match_working_dir(search, distance: 1, require_last: true)
+      file = database_path
+      notify('{r}No na database found', exit_code: 1) unless File.exist?(file)
+
+      dirs = file.read_file.split("\n")
+
+      optional = search.map { |t| t[:token] }
+      required = search.filter { |s| s[:required] }.map { |t| t[:token] }
+      negated = search.filter { |s| s[:negate] }.map { |t| t[:token] }
+
+      NA.notify("{dw}Optional directory regex: {x}#{optional.map(&:dir_to_rx)}", debug: true)
+      NA.notify("{dw}Required directory regex: {x}#{required.map(&:dir_to_rx)}", debug: true)
+      NA.notify("{dw}Negated directory regex: {x}#{negated.map { |t| t.dir_to_rx(distance: 1, require_last: false) }}", debug: true)
+
+      if require_last
+        dirs.delete_if { |d| !d.sub(/\.#{NA.extension}$/, '').dir_matches(any: optional, all: required, none: negated) }
+      else
+        dirs.delete_if { |d| !d.sub(/\.#{NA.extension}$/, '').dir_matches(any: optional, all: required, none: negated, distance: 2, require_last: false) }
+      end
+
+      dirs = dirs.sort.uniq
+      if dirs.empty? && require_last
+        NA.notify("{y}No matches, loosening search", debug: true)
+        match_working_dir(search, distance: 2, require_last: false)
+      else
+        dirs
+      end
+    end
+
     private
 
     ##
@@ -446,31 +770,6 @@ module NA
       [optional, required, negated]
     end
 
-    ##
-    ## Find a matching path using semi-fuzzy matching.
-    ## Search tokens can include ! and + to negate or make
-    ## required.
-    ##
-    ## @param      search    [Array] search tokens to match
-    ## @param      distance  [Integer] allowed distance
-    ##                       between characters
-    ##
-    def match_working_dir(search, distance: 1)
-      file = database_path
-      notify('{r}No na database found', exit_code: 1) unless File.exist?(file)
-
-      dirs = file.read_file.split("\n")
-
-      optional = search.map { |t| t[:token] }
-      required = search.filter { |s| s[:required] }.map { |t| t[:token] }
-
-      NA.notify("{bw}Optional directory regex: {x}#{optional.map(&:dir_to_rx)}", debug: true)
-      NA.notify("{bw}Required directory regex: {x}#{required.map(&:dir_to_rx)}", debug: true)
-
-      dirs.delete_if { |d| !d.sub(/\.#{NA.extension}$/, '').dir_matches(any: optional, all: required) }
-      dirs.sort.uniq
-    end
-
     ##
     ## Save a todo file path to the database
     ##

data/lib/na/project.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module NA
+  class Project < Hash
+    attr_accessor :project, :indent, :line
+
+    def initialize(project, indent = 0, line = 0)
+      super()
+      @project = project
+      @indent = indent
+      @line = line
+    end
+
+    def to_s
+      { project: @project, indent: @indent, line: @line }.to_s
+    end
+
+    def inspect
+      [
+        "@project: #{@project}",
+        "@indent: #{@indent}",
+        "@line: #{@line}"
+      ].join("\n")
+    end
+  end
+end

data/lib/na/string.rb

@@ -94,14 +94,18 @@ class ::String
   ##             slashes and requires that last segment
   ##             match last segment of target path
   ##
-  ## @param      distance  The distance
+  ## @param      distance      The distance allowed between characters
+  ## @param      require_last  Require match to be last element in path
   ##
-  def dir_to_rx(distance: 2)
-    "#{split(%r{[/:]}).map { |comp| comp.split('').join(".{0,#{distance}}").gsub(/\*/, '[^ ]*?') }.join('.*?/.*?')}[^/]*?$"
+  def dir_to_rx(distance: 1, require_last: true)
+    "#{split(%r{[/:]}).map { |comp| comp.split('').join(".{0,#{distance}}").gsub(/\*/, '[^ ]*?') }.join('.*?/.*?')}#{require_last ? '[^/]*?$' : ''}"
   end
 
-  def dir_matches(any: [], all: [])
-    matches_any(any.map(&:dir_to_rx)) && matches_all(all.map(&:dir_to_rx))
+  def dir_matches(any: [], all: [], none: [], require_last: true, distance: 1)
+    any_rx = any.map { |q| q.dir_to_rx(distance: distance, require_last: require_last) }
+    all_rx = all.map { |q| q.dir_to_rx(distance: distance, require_last: require_last) }
+    none_rx = none.map { |q| q.dir_to_rx(distance: distance, require_last: false) }
+    matches_any(any_rx) && matches_all(all_rx) && matches_none(none_rx)
   end
 
   def matches(any: [], all: [], none: [])

data/lib/na/version.rb

@@ -1,3 +1,3 @@
 module Na
-  VERSION = '1.1.25'
+  VERSION = '1.2.0'
 end

data/lib/na.rb

@@ -11,6 +11,7 @@ require 'tty-which'
 require 'na/hash'
 require 'na/colors'
 require 'na/string'
+require 'na/project'
 require 'na/action'
 require 'na/next_action'
 require 'na/prompt'

data/src/README.md

@@ -9,7 +9,7 @@
 _If you're one of the rare people like me who find this useful, feel free to
 [buy me some coffee][donate]._
 
-The current version of `na` is <!--VER-->1.1.24<!--END VER-->.
+The current version of `na` is <!--VER-->1.1.26<!--END VER-->.
 
 `na` ("next action") is a command line tool designed to make it easy to see what your next actions are for any project, right from the command line. It works with TaskPaper-formatted files (but any plain text format will do), looking for `@na` tags (or whatever you specify) in todo files in your current folder. 
 
@@ -100,16 +100,70 @@ Examples:
 @cli(bundle exec bin/na help next)
 ```
 
+##### projects
+
+List all projects in a file. If arguments are provided, they're used to match a todo file from history, otherwise the todo file(s) in the current directory will be used.
+
+```
+@cli(bundle exec bin/na help projects)
+```
+
+##### saved
+
+The saved command runs saved searches. To save a search, add `--save SEARCH_NAME` to a `find` or `tagged` command. The arguments provided on the command line will be saved to a search file (`/.local/share/na/saved_searches.yml`), with the search named with the SEARCH_NAME parameter. You can then run the search again with `na saved SEARCH_NAME`. Repeating the SEARCH_NAME with a new `find/tagged` command will overwrite the previous definition.
+
+Search names can be partially matched when calling them, so if you have a search named "overdue," you can match it with `na saved over` (shortest match will be used).
+
+Run `na saved` without an argument to list your saved searches.
+
+```
+@cli(bundle exec bin/na help saved)
+```
+
 ##### tagged
 
 Example: `na tagged feature +maybe`.
 
-Separate multiple tags with spaces or commas. By default tags are combined with AND, so actions matching all of the tags listed will be displayed. Use `+` to make a tag required and `!` to negate a tag (only display if the action does _not_ contain the tag). When `+` and/or `!` are used, undecorated tokens become optional matches. Use `-v` to invert the search and display all actions that _don't_ match.
+Separate multiple tags/value comparisons with commas. By default tags are combined with AND, so actions matching all of the tags listed will be displayed. Use `+` to make a tag required and `!` to negate a tag (only display if the action does _not_ contain the tag). When `+` and/or `!` are used, undecorated tokens become optional matches. Use `-v` to invert the search and display all actions that _don't_ match.
+
+You can also perform value comparisons on tags. A value in a TaskPaper tag is added by including it in parenthesis after the tag, e.g. `@due(2022-10-10 05:00)`. You can perform numeric comparisons with `<`, `>`, `<=`, `>=`, `==`, and `!=`. If comparing to a date, you can use natural language, e.g. `na tagged "due<today"`.
+
+To perform a string comparison, you can use `*=` (contains), `^=` (starts with), `$=` (ends with), or `=` (matches). E.g. `na tagged "note*=video"`.
 
 ```
 @cli(bundle exec bin/na help show)
 ```
 
+##### todos
+
+List all known todo files from history.
+
+```
+@cli(bundle exec bin/na help todos)
+```
+
+##### update
+
+Example: `na update --in na --archive my cool action`
+
+The above will locate a todo file matching "na" in todo history, find any action matching "my cool action", add a dated @done tag and move it to the Archive project, creating it if needed. If multiple actions are matched, a menu is presented (multi-select if fzf is available).
+
+This command will perform actions (tag, untag, complete, archive, add note, etc.) on existing actions by matching your search text. Arguments will be interpreted as search tokens similar to `na find`. You can use `--exact` and `--regex`, as well as wildcards in the search string. You can also use `--tagged TAG_QUERY` in addition to or instead of a search query.
+
+You can specify a particular todo file using `--file PATH` or any todo from history using `--in QUERY`.
+
+If more than one file is matched, a menu will be presented, multiple selections allowed. If multiple actions match the search within the selected file(s), a menu will be presented. If you have fzf installed, you can select one action to update with return, or use tab to mark multiple tasks to which the action will be applied. With gum you can use j, k, and x to mark multiple actions. Use the `--all` switch to force operation on all matched tasks, skipping the menu.
+
+Any time an update action is carried out, a backup of the file before modification will be made in the same directory with a `~` appended to the file extension (e.g. "marked.taskpaper" is backed up to "marked.taskpaper~"). Only one undo step is available, but if something goes wrong (and this feature is still experimental, so be wary), you can just copy the "~" file back to the original.
+
+You can specify a new project for an action (moving it) with `--proj PROJECT_PATH`. A project path is hierarchical, with each level separated by a colon or slash. If the project path provided roughly matches an existing project, e.g. "mark:bug" would match "Marked:Bugs", then that project will be used. If no match is found, na will offer to generate a new project/hierarchy for the path provided. Strings will be exact but the first letter will be uppercased.
+
+See the help output for a list of available actions.
+
+```
+@cli(bundle exec bin/na help update)
+```
+
 ### Configuration
 
 Global options such as todo extension and default next action tag can be stored permanently by using the `na initconfig` command. Run na with the global options you'd like to set, and add `initconfig` at the end of the command. A file will be written to `~/.na.rc`. You can edit this manually, or just update it using the `initconfig --force` command to overwrite it with new settings.
@@ -148,11 +202,11 @@ You can add a prompt command to your shell to have na automatically list your ne
 
 After installing a hook, you'll need to close your terminal and start a new session to initialize the new commands.
 
-
 ### Misc
 
-If you have [gum][] installed, na will use it for command line input when adding tasks and notes.
+If you have [gum][] installed, na will use it for command line input when adding tasks and notes. If you have [fzf][] installed, it will be used for menus, falling back to gum if available.
 
+[fzf]: https://github.com/junegunn/fzf
 [gum]: https://github.com/charmbracelet/gum
 [donate]: http://brettterpstra.com/donate/
 [github]: https://github.com/ttscoff/na_gem/