na 1.2.85 → 1.2.87

data/bin/commands/tagged.rb

@@ -2,124 +2,152 @@
 
 class App
   extend GLI::App
-  desc "Find actions matching a tag"
+  desc 'Find actions matching a tag'
   long_desc 'Finds actions with tags matching the arguments. An action is shown if it
   contains all of the tags listed. Add a + before a tag to make it required
   and others optional. You can specify values using TAG=VALUE pairs.
   Use <, >, and = for numeric comparisons, and *=, ^=, $=, or =~ (regex) for text comparisons.
   Date comparisons use natural language (`na tagged "due<=today"`) and
   are detected automatically.'
-  arg_name "TAG[=VALUE]"
+  arg_name 'TAG[=VALUE]'
   command %i[tagged] do |c|
-    c.example "na tagged maybe", desc: "Show all actions tagged @maybe"
-    c.example 'na tagged -d 3 "feature, idea"', desc: "Show all actions tagged @feature AND @idea, recurse 3 levels"
-    c.example 'na tagged --or "feature, idea"', desc: "Show all actions tagged @feature OR @idea"
-    c.example 'na tagged "priority>=4"', desc: "Show actions with @priority(4) or @priority(5)"
-    c.example 'na tagged "due<in 2 days"', desc: "Show actions with a due date coming up in the next 2 days"
-
-    c.desc "Recurse to depth"
-    c.arg_name "DEPTH"
+    c.example 'na tagged maybe', desc: 'Show all actions tagged @maybe'
+    c.example 'na tagged -d 3 "feature, idea"', desc: 'Show all actions tagged @feature AND @idea, recurse 3 levels'
+    c.example 'na tagged --or "feature, idea"', desc: 'Show all actions tagged @feature OR @idea'
+    c.example 'na tagged "priority>=4"', desc: 'Show actions with @priority(4) or @priority(5)'
+    c.example 'na tagged "due<in 2 days"', desc: 'Show actions with a due date coming up in the next 2 days'
+
+    c.desc 'Recurse to depth'
+    c.arg_name 'DEPTH'
     c.default_value 1
     c.flag %i[d depth], type: :integer, must_match: /^\d+$/
 
-    c.desc "Show actions from a specific todo file in history. May use wildcards (* and ?)"
-    c.arg_name "TODO_PATH"
+    c.desc 'Show actions from a specific todo file in history. May use wildcards (* and ?)'
+    c.arg_name 'TODO_PATH'
     c.flag %i[in]
 
-    c.desc "Include notes in output"
+    c.desc 'Include notes in output'
     c.switch %i[notes], negatable: true, default_value: false
 
-    c.desc "Combine tags with OR, displaying actions matching ANY of the tags"
+    c.desc 'Show per-action durations and total'
+    c.switch %i[times], negatable: false
+
+    c.desc 'Format durations in human-friendly form'
+    c.switch %i[human], negatable: false
+
+    c.desc 'Show only actions that have a duration (@started and @done)'
+    c.switch %i[only_timed], negatable: false
+
+    c.desc 'Output times as JSON object (implies --times and --done)'
+    c.switch %i[json_times], negatable: false
+
+    c.desc 'Output only elapsed time totals (implies --times and --done)'
+    c.switch %i[only_times], negatable: false
+
+    c.desc 'Combine tags with OR, displaying actions matching ANY of the tags'
     c.switch %i[o or], negatable: false
 
-    c.desc "Show actions from a specific project"
-    c.arg_name "PROJECT[/SUBPROJECT]"
+    c.desc 'Show actions from a specific project'
+    c.arg_name 'PROJECT[/SUBPROJECT]'
     c.flag %i[proj project]
 
-    c.desc "Filter results using search terms"
-    c.arg_name "QUERY"
+    c.desc 'Filter results using search terms'
+    c.arg_name 'QUERY'
     c.flag %i[search find grep], multiple: true
 
-    c.desc "Include notes in search"
+    c.desc 'Include notes in search'
     c.switch %i[search_notes], negatable: true, default_value: true
 
-    c.desc "Search query is regular expression"
+    c.desc 'Search query is regular expression'
     c.switch %i[regex], negatable: false
 
-    c.desc "Search query is exact text match (not tokens)"
+    c.desc 'Search query is exact text match (not tokens)'
     c.switch %i[exact], negatable: false
 
-    c.desc "Include @done actions"
+    c.desc 'Include @done actions'
     c.switch %i[done]
 
-    c.desc "Show actions not matching tags"
+    c.desc 'Show actions not matching tags'
     c.switch %i[v invert], negatable: false
 
-    c.desc "Save this search for future use"
-    c.arg_name "TITLE"
+    c.desc 'Save this search for future use'
+    c.arg_name 'TITLE'
     c.flag %i[save]
 
-    c.desc "Output actions nested by file"
+    c.desc 'Output actions nested by file'
     c.switch %i[nest], negatable: false
 
-    c.desc "No filename in output"
+    c.desc 'No filename in output'
     c.switch %i[no_file], negatable: false
 
-    c.desc "Output actions nested by file and project"
+    c.desc 'Output actions nested by file and project'
     c.switch %i[omnifocus], negatable: false
 
     c.action do |global_options, options, args|
       options[:nest] = true if options[:omnifocus]
 
       if options[:save]
-        title = options[:save].gsub(/[^a-z0-9]/, "_").gsub(/_+/, "_")
-        cmd = NA.command_line.join(" ").sub(/ --save[= ]*\S+/, "").split(" ").map { |t| %("#{t}") }.join(" ")
+        title = options[:save].gsub(/[^a-z0-9]/, '_').gsub(/_+/, '_')
+        cmd = NA.command_line.join(' ').sub(/ --save[= ]*\S+/, '').split.map { |t| %("#{t}") }.join(' ')
         NA.save_search(title, cmd)
       end
 
       depth = if global_options[:recurse] && options[:depth].nil? && global_options[:depth] == 1
-          3
-        else
-          options[:depth].nil? ? global_options[:depth].to_i : options[:depth].to_i
-        end
+                3
+              else
+                options[:depth].nil? ? global_options[:depth].to_i : options[:depth].to_i
+              end
 
       tags = []
 
-      all_req = args.join(" ") !~ /(?<=[, ])[+!-]/ && !options[:or]
-      args.join(",").split(/ *, */).each do |arg|
+      all_req = args.join(' ') !~ /(?<=[, ])[+!-]/ && !options[:or]
+      args.join(',').split(/ *, */).each do |arg|
         m = arg.match(/^(?<req>[+!-])?(?<tag>[^ =<>$~\^]+?) *(?:(?<op>[=<>~]{1,2}|[*$\^]=) *(?<val>.*?))?$/)
         next if m.nil?
 
         tags.push({
-                    tag: m["tag"].sub(/^@/, "").wildcard_to_rx,
-                    comp: m["op"],
-                    value: m["val"],
-                    required: all_req || (!m["req"].nil? && m["req"] == "+"),
-                    negate: !m["req"].nil? && m["req"] =~ /[!-]/,
+                    tag: m['tag'].sub(/^@/, '').wildcard_to_rx,
+                    comp: m['op'],
+                    value: m['val'],
+                    required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                    negate: !m['req'].nil? && m['req'] =~ /[!-]/
                   })
       end
 
       search_for_done = false
       tags.each { |tag| search_for_done = true if tag[:tag] =~ /done/ }
-      tags.push({ tag: "done", value: nil, negate: true }) unless search_for_done || options[:done]
-      options[:done] = true if search_for_done
+      if options[:json_times]
+        options[:times] = true
+        options[:done] = true
+      elsif options[:only_times]
+        options[:times] = true
+        options[:done] = true
+      elsif options[:only_timed]
+        options[:times] = true
+        options[:done] = true
+      elsif options[:times]
+        options[:done] = true
+      else
+        tags.push({ tag: 'done', value: nil, negate: true }) unless search_for_done || options[:done]
+        options[:done] = true if search_for_done
+      end
 
       tokens = nil
       if options[:search]
         if options[:exact]
-          tokens = options[:search].join(" ")
+          tokens = options[:search].join(' ')
         elsif options[:regex]
-          tokens = Regexp.new(options[:search].join(" "), Regexp::IGNORECASE)
+          tokens = Regexp.new(options[:search].join(' '), Regexp::IGNORECASE)
         else
           tokens = []
-          all_req = options[:search].join(" ") !~ /(?<=[, ])[+!-]/ && !options[:or]
+          all_req = options[:search].join(' ') !~ /(?<=[, ])[+!-]/ && !options[:or]
 
-          options[:search].join(" ").split(/ /).each do |arg|
+          options[:search].join(' ').split(/ /).each do |arg|
             m = arg.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
             tokens.push({
-                          token: m["tok"],
-                          required: all_req || (!m["req"].nil? && m["req"] == "+"),
-                          negate: !m["req"].nil? && m["req"] =~ /[!-]/,
+                          token: m['tok'],
+                          required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                          negate: !m['req'].nil? && m['req'] =~ /[!-]/
                         })
           end
         end
@@ -132,9 +160,9 @@ class App
         options[:in].split(/ *, */).each do |a|
           m = a.match(/^(?<req>[+\-!])?(?<tok>.*?)$/)
           todos.push({
-                       token: m["tok"],
-                       required: all_req || (!m["req"].nil? && m["req"] == "+"),
-                       negate: !m["req"].nil? && m["req"] =~ /[!-]/,
+                       token: m['tok'],
+                       required: all_req || (!m['req'].nil? && m['req'] == '+'),
+                       negate: !m['req'].nil? && m['req'] =~ /[!-]/
                      })
         end
       end
@@ -152,17 +180,22 @@ class App
                             require_na: false })
 
       regexes = if tokens.is_a?(Array)
-          tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
-        else
-          [tokens]
-        end
+                  tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
+                else
+                  [tokens]
+                end
       todo.actions.output(depth,
                           { files: todo.files,
                             regexes: regexes,
                             notes: options[:notes],
                             nest: options[:nest],
                             nest_projects: options[:omnifocus],
-                            no_files: options[:no_file] })
+                            no_files: options[:no_file],
+                            times: options[:times],
+                            human: options[:human],
+                            only_timed: options[:only_timed],
+                            json_times: options[:json_times],
+                            only_times: options[:only_times] })
     end
   end
 end

data/bin/commands/update.rb

@@ -9,6 +9,17 @@ class App
   allow you to pick which file to act on.'
   arg_name 'ACTION'
   command %i[update] do |c|
+    c.desc 'Started time (natural language or ISO)'
+    c.arg_name 'DATE'
+    c.flag %i[started], type: :date_begin
+
+    c.desc 'End/Finished time (natural language or ISO)'
+    c.arg_name 'DATE'
+    c.flag %i[end finished], type: :date_end
+
+    c.desc 'Duration (e.g. 45m, 2h, 1d2h30m, or minutes)'
+    c.arg_name 'DURATION'
+    c.flag %i[duration], type: :duration
     c.example 'na update --remove na "An existing task"',
               desc: 'Find "An existing task" action and remove the @na tag from it'
     c.example 'na update --tag waiting "A bug I need to fix" -p 4 -n',
@@ -164,13 +175,33 @@ class App
 
       options[:exact] = true unless options[:replace].nil?
 
+      # Check for PATH:LINE format in arguments
+      target_file = nil
+      target_line = nil
+      if args.count.positive?
+        pathline_match = args.join(' ').strip.match(/^(.+):(\d+)$/)
+        if pathline_match
+          target_file = pathline_match[1]
+          target_line = pathline_match[2].to_i
+
+          # Verify file exists
+          if File.exist?(target_file)
+            options[:file] = target_file
+            options[:target_line] = target_line
+            action = nil  # Skip search processing
+          else
+            NA.notify("#{NA.theme[:error]}File not found: #{target_file}", exit_code: 1)
+          end
+        end
+      end
+
       if args.count.positive?
         action = args.join(' ').strip
       else
         action = nil
       end
       tokens = nil
-      if action && !action.empty?
+      if action && !action.empty? && !target_line
         if options[:exact]
           tokens = action
         elsif options[:regex]
@@ -218,10 +249,11 @@ class App
           done: options[:done]
         })
         todo.actions.each do |action_obj|
-          # Format: filename:project:parent > action
-          display = "#{File.basename(action_obj.file)}:#{action_obj.project}:#{action_obj.parent.join('>')} | #{action_obj.action}"
+          # Format: filename:LINENUM:parent > action
+          # Include line number in display for unique matching
+          display = "#{File.basename(action_obj.file_path)}:#{action_obj.file_line}:#{action_obj.parent.join('>')} | #{action_obj.action}"
           candidate_actions << display
-          targets_for_selection << { file: action_obj.file, line: action_obj.line, action: action_obj }
+          targets_for_selection << { file: action_obj.file_path, line: action_obj.file_line, action: action_obj }
         end
       end
 
@@ -237,9 +269,24 @@ class App
         if selector
           require 'open3'
           input = candidate_actions.join("\n")
-          output, _ = Open3.capture2("echo \"#{input.gsub('"', '\"')}\" | #{selector}")
-          selected = output.split("\n").map(&:strip).reject(&:empty?)
-          selected_indices = candidate_actions.each_index.select { |i| selected.include?(candidate_actions[i]) }
+
+          # Use popen3 to properly handle stdin for fzf
+          Open3.popen3(selector) do |stdin, stdout, stderr, wait_thr|
+            stdin.write(input)
+            stdin.close
+
+            output = stdout.read
+
+            selected = output.split("\n").map(&:strip).reject(&:empty?)
+
+            # Track which candidates have been matched to avoid duplicates
+            selected_indices = []
+            candidate_actions.each_index do |i|
+              if selected.include?(candidate_actions[i])
+                selected_indices << i unless selected_indices.include?(i)
+              end
+            end
+          end
         else
           # Fallback: select all or prompt for search string
           selected_indices = (0...candidate_actions.size).to_a
@@ -263,7 +310,10 @@ class App
         options[:archive],
         options[:restore],
         options[:delete],
-        options[:edit]
+        options[:edit],
+        options[:started],
+        (options[:end] || options[:finished]),
+        options[:duration]
       ].any?
       unless actionable
         # Interactive menu for actions
@@ -325,13 +375,23 @@ class App
           options[:delete] = true
         when :finish
           options[:finish] = true
+          # Timed finish? Prompt user for optional start/date inputs
+          if NA.yn(NA::Color.template("#{NA.theme[:prompt]}Timed?"), default: false)
+            # Ask for start date expression
+            start_expr = nil
+            if TTY::Which.exist?('gum')
+              gum = TTY::Which.which('gum')
+              prompt = 'Enter start date/time (e.g. "30 minutes ago" or "3pm"):'
+              start_expr = `#{gum} input --placeholder "#{prompt}"`.strip
+            else
+              print 'Enter start date/time (e.g. "30 minutes ago" or "3pm"): '
+              start_expr = (STDIN.gets || '').strip
+            end
+            start_time = NA::Types.parse_date_begin(start_expr)
+            options[:started] = start_time if start_time
+          end
         when :edit
-          # Open editor for the selected action and update its content
-          edit_action = targets_for_selection[selected_indices.first][:action]
-          editor_content = "#{edit_action.action}\n#{edit_action.note.join("\n")}"
-          new_action, new_note = NA::Editor.format_input(NA::Editor.fork_editor(editor_content))
-          edit_action.action = new_action
-          edit_action.note = new_note
+          # Just set the flag - multi-action editor will handle it below
           options[:edit] = true
         when :priority
           options[:priority] = param_value
@@ -384,7 +444,17 @@ class App
         end
       end
       did_direct_update = false
+
+      # Group selected actions by file for batch processing
+      actions_by_file = {}
       selected_indices.each do |idx|
+        file = targets_for_selection[idx][:file]
+        actions_by_file[file] ||= []
+        actions_by_file[file] << targets_for_selection[idx][:action]
+      end
+
+      # Process each file's actions
+      actions_by_file.each do |file, action_list|
         # Rebuild all derived variables from options after menu-driven assignment
         add_tags = options[:tag] ? options[:tag].join(',').split(/ *, */).map { |t| t.sub(/^@/, '') } : []
         remove_tags = options[:remove] ? options[:remove].join(',').split(/ *, */).map { |t| t.sub(/^@/, '') } : []
@@ -399,29 +469,64 @@ class App
         if options[:note] && defined?(param_value) && param_value
           note_val = [param_value]
         end
-        # Pass the selected action object as 'add', set search to nil
-        # Pass the exact selected action object to update_action, bypassing all search/filter logic
-        target = targets_for_selection[idx][:file]
-        action_obj = targets_for_selection[idx][:action]
-        # Direct action mode: update only the selected action in the known file
-        NA.update_action(target, nil,
-          add: action_obj,
-          add_tag: add_tags,
-          all: true,
-          append: append,
-          delete: options[:delete],
-          done: options[:done],
-          edit: options[:edit],
-          finish: options[:finish],
-          move: target_proj,
-          note: note_val,
-          overwrite: options[:overwrite],
-          priority: priority,
-          project: options[:project],
-          remove_tag: remove_tags,
-          replace: options[:replace],
-          search_note: options[:search_notes],
-          tagged: nil)
+
+        # Handle edit with multiple actions
+        if options[:edit]
+          # Open editor once with all actions for this file
+          editor_content = NA::Editor.format_multi_action_input(action_list)
+          edited_content = NA::Editor.fork_editor(editor_content)
+          edited_actions = NA::Editor.parse_multi_action_output(edited_content)
+
+          # If markers were removed but we have the same number of actions, match by position
+          if edited_actions.empty? && action_list.size > 0
+            # Parse content line by line, skipping comments and blanks
+            non_comment_lines = edited_content.lines.map(&:strip).reject { |l| l.empty? || l.start_with?('#') }
+
+            # Match each non-comment line to an action by position
+            action_list.each_with_index do |action_obj, idx|
+              if non_comment_lines[idx]
+                # Split into action and notes
+                lines = non_comment_lines[idx..-1]
+                action_text = lines[0]
+                note_lines = lines[1..-1] || []
+
+                # Store by file:line key
+                key = "#{action_obj.file_path}:#{action_obj.file_line}"
+                edited_actions[key] = [action_text, note_lines]
+              end
+            end
+          end
+
+          # Update each action with edited content
+          action_list.each do |action_obj|
+            key = "#{action_obj.file_path}:#{action_obj.file_line}"
+            if edited_actions[key]
+              action_obj.action, action_obj.note = edited_actions[key]
+            end
+          end
+        end
+
+        # Update each action (process from bottom to top to avoid line shifts)
+        action_list.sort_by(&:file_line).reverse.each do |action_obj|
+          NA.update_action(file, nil,
+            add: action_obj,
+            add_tag: add_tags,
+            all: true,
+            append: append,
+            delete: options[:delete],
+            done: options[:done],
+            edit: false,  # Already handled above
+            finish: options[:finish],
+            move: target_proj,
+            note: note_val,
+            overwrite: options[:overwrite],
+            priority: priority,
+            project: options[:project],
+            remove_tag: remove_tags,
+            replace: options[:replace],
+            search_note: options[:search_notes],
+            tagged: nil)
+        end
         did_direct_update = true
       end
       if did_direct_update
@@ -539,8 +644,15 @@ class App
 
       NA.notify("#{NA.theme[:error]}No search terms provided", exit_code: 1) if tokens.nil? && options[:tagged].empty?
 
+      # Handle target_line if provided (from PATH:LINE format)
+      search_tokens = if options[:target_line]
+                       { target_line: options[:target_line] }
+                     else
+                       tokens
+                     end
+
       targets.each do |target|
-        NA.update_action(target, tokens,
+        NA.update_action(target, search_tokens,
                          add_tag: add_tags,
                          all: options[:all],
                          append: append,
@@ -556,7 +668,10 @@ class App
                          remove_tag: remove_tags,
                          replace: options[:replace],
                          search_note: options[:search_notes],
-                         tagged: tags)
+                         tagged: tags,
+                         started_at: options[:started],
+                         done_at: (options[:end] || options[:finished]),
+                         duration_seconds: options[:duration])
       end
     end
   end

data/bin/na

@@ -195,6 +195,12 @@ class App
       true
     end
   end
+
+  # Register custom GLI types for natural language dates and durations
+  # Return original string if parsing fails so commands can handle fallback parsing
+  accept(:date_begin) { |v| NA::Types.parse_date_begin(v) || v }
+  accept(:date_end) { |v| NA::Types.parse_date_end(v) || v }
+  accept(:duration) { |v| NA::Types.parse_duration_seconds(v) }
 end
 
 NA.stdin = $stdin.read.strip if $stdin.stat.size.positive? || $stdin.fcntl(Fcntl::F_GETFL, 0).zero?