na 1.2.86 → 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',
@@ -299,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
@@ -361,6 +375,21 @@ 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
           # Just set the flag - multi-action editor will handle it below
           options[:edit] = true
@@ -477,8 +506,8 @@ class App
           end
         end
 
-        # Update each action
-        action_list.each do |action_obj|
+        # 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,
@@ -639,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?

data/lib/na/action.rb

@@ -63,8 +63,8 @@ module NA
     # @param note [Array<String>] Notes to set
     # @return [void]
     # @example
-    #   action.process(priority: 5, finish: true, add_tag: ['urgent'], remove_tag: ['waiting'], note: ['Call Bob'])
-    def process(priority: 0, finish: false, add_tag: [], remove_tag: [], note: [])
+    #   action.process(priority: 5, finish: true, add_tag: ["urgent"], remove_tag: ["waiting"], note: ["Call Bob"], started_at: Time.now, done_at: Time.now)
+    def process(priority: 0, finish: false, add_tag: [], remove_tag: [], note: [], started_at: nil, done_at: nil, duration_seconds: nil)
       string = @action.dup
 
       if priority&.positive?
@@ -84,9 +84,32 @@ module NA
         string += " @#{tag}"
       end
 
-      string = "#{string.strip} @done(#{Time.now.strftime('%Y-%m-%d %H:%M')})" if finish && string !~ /(?<=\A| )@done/
+      # Compute started/done from duration if provided
+      if duration_seconds && (done_at || finish)
+        done_time = done_at || Time.now
+        started_at ||= done_time - duration_seconds.to_i
+      elsif duration_seconds && started_at
+        done_at ||= started_at + duration_seconds.to_i
+      end
+
+      # Insert @started if provided
+      if started_at
+        string.gsub!(/(?<=\A| )@start(?:ed)?\(.*?\)/i, '')
+        string.strip!
+        string += " @started(#{started_at.strftime('%Y-%m-%d %H:%M')})"
+      end
+
+      # Insert @done if provided or finishing
+      if done_at
+        string.gsub!(/(?<=\A| )@done\(.*?\)/i, '')
+        string.strip!
+        string += " @done(#{done_at.strftime('%Y-%m-%d %H:%M')})"
+      elsif finish && string !~ /(?<=\A| )@done/
+        string = "#{string.strip} @done(#{Time.now.strftime('%Y-%m-%d %H:%M')})"
+      end
 
       @action = string.expand_date_tags
+      @tags = scan_tags
       @note = note unless note.empty?
     end
 

data/lib/na/actions.rb

@@ -26,12 +26,26 @@ module NA
           notes: false,
           nest: false,
           nest_projects: false,
-          no_files: false
+          no_files: false,
+          times: false,
+          human: false,
+          only_timed: false,
+          json_times: false
         }
         config = defaults.merge(config)
 
         return if config[:files].nil?
 
+        # Optionally filter to only actions with a computable duration (@started and @done)
+        filtered_actions = if config[:only_timed]
+                             self.select do |a|
+                               t = a.tags
+                               (t['started'] || t['start']) && t['done']
+                             end
+                           else
+                             self
+                           end
+
         if config[:nest]
           template = NA.theme[:templates][:default]
           template = NA.theme[:templates][:no_file] if config[:no_files]
@@ -40,7 +54,7 @@ module NA
           out = []
 
           if config[:nest_projects]
-            each do |action|
+            filtered_actions.each do |action|
               parent_files[action.file] ||= []
               parent_files[action.file].push(action)
             end
@@ -54,7 +68,7 @@ module NA
             template = NA.theme[:templates][:default]
             template = NA.theme[:templates][:no_file] if config[:no_files]
 
-            each do |action|
+            filtered_actions.each do |action|
               parent_files[action.file] ||= []
               parent_files[action.file].push(action)
             end
@@ -94,14 +108,71 @@ module NA
 
           # Optimize output generation - compile all output first, then apply regexes
           output = String.new
+          total_seconds = 0
+          totals_by_tag = Hash.new(0)
+          timed_items = []
           NA::Benchmark.measure('Generate action strings') do
-            each_with_index do |action, idx|
+            filtered_actions.each_with_index do |action, idx|
               # Generate raw output without regex processing
-              output << action.pretty(template: { templates: { output: template } }, regexes: [], notes: config[:notes])
-              output << "\n" unless idx == size - 1
+              line = action.pretty(template: { templates: { output: template } }, regexes: [], notes: config[:notes])
+
+              if config[:times]
+                # compute duration from @started/@done
+                tags = action.tags
+                begun = tags['started'] || tags['start']
+                finished = tags['done']
+                if begun && finished
+                  begin
+                    start_t = Time.parse(begun)
+                    end_t = Time.parse(finished)
+                    secs = [end_t - start_t, 0].max.to_i
+                    total_seconds += secs
+                    dur_color = NA.theme[:duration] || '{y}'
+                    line << NA::Color.template(" #{dur_color}[#{format_duration(secs, human: config[:human])}]{x}")
+
+                    # collect for JSON output
+                    timed_items << {
+                      action: NA::Color.uncolor(action.action),
+                      started: start_t.iso8601,
+                      ended: end_t.iso8601,
+                      duration: secs
+                    }
+
+                    # accumulate per-tag durations (exclude time-control tags)
+                    tags.each_key do |k|
+                      next if k =~ /^(start|started|done)$/i
+
+                      totals_by_tag[k.sub(/^@/, '')] += secs
+                    end
+                  rescue StandardError
+                    # ignore parse errors
+                  end
+                end
+              end
+
+              unless config[:only_times]
+                output << line
+                output << "\n" unless idx == filtered_actions.size - 1
+              end
             end
           end
 
+          # If JSON output requested, emit JSON and return immediately
+          if config[:json_times]
+            require 'json'
+            json = {
+              timed: timed_items,
+              tags: totals_by_tag.map { |k, v| { tag: k, duration: v } }.sort_by { |h| -h[:duration] },
+              total: {
+                seconds: total_seconds,
+                timestamp: format_duration(total_seconds, human: false),
+                human: format_duration(total_seconds, human: true)
+              }
+            }
+            puts JSON.pretty_generate(json)
+            return
+          end
+
           # Apply regex highlighting to the entire output at once
           if config[:regexes].any?
             NA::Benchmark.measure('Apply regex highlighting') do
@@ -109,11 +180,70 @@ module NA
             end
           end
 
+          if config[:times] && total_seconds.positive?
+            # Build Markdown table of per-tag totals
+            if totals_by_tag.empty?
+              # No tag totals, just show total line
+              dur_color = NA.theme[:duration] || '{y}'
+              output << "\n"
+              output << NA::Color.template("{x}#{dur_color}Total time: [#{format_duration(total_seconds, human: config[:human])}]{x}")
+            else
+              rows = totals_by_tag.sort_by { |_, v| -v }.map do |tag, secs|
+                disp = format_duration(secs, human: config[:human])
+                ["@#{tag}", disp]
+              end
+              # Pre-compute total display for width calculation
+              total_disp = format_duration(total_seconds, human: config[:human])
+              # Determine column widths, including footer labels/values
+              tag_header = 'Tag'
+              dur_header = config[:human] ? 'Duration (human)' : 'Duration'
+              tag_width = ([tag_header.length, 'Total'.length] + rows.map { |r| r[0].length }).max
+              dur_width = ([dur_header.length, total_disp.length] + rows.map { |r| r[1].length }).max
+
+              # Header
+              output << "\n"
+              output << "| #{tag_header.ljust(tag_width)} | #{dur_header.ljust(dur_width)} |\n"
+              # Separator for header
+              output << "| #{'-' * tag_width} | #{'-' * dur_width} |\n"
+              # Body rows
+              rows.each do |tag, disp|
+                output << "| #{tag.ljust(tag_width)} | #{disp.ljust(dur_width)} |\n"
+              end
+              # Footer separator (kramdown footer separator with '=') and footer row
+              output << "| #{'=' * tag_width} | #{'=' * dur_width} |\n"
+              output << "| #{'Total'.ljust(tag_width)} | #{total_disp.ljust(dur_width)} |\n"
+            end
+          end
+
           NA::Benchmark.measure('Pager.page call') do
             NA::Pager.page(output)
           end
         end
       end
     end
+
+    private
+
+    def format_duration(secs, human: false)
+      return '' if secs.nil?
+
+      secs = secs.to_i
+      days = secs / 86_400
+      rem = secs % 86_400
+      hours = rem / 3600
+      rem %= 3600
+      minutes = rem / 60
+      seconds = rem % 60
+      if human
+        parts = []
+        parts << "#{days} days" if days.positive?
+        parts << "#{hours} hours" if hours.positive?
+        parts << "#{minutes} minutes" if minutes.positive?
+        parts << "#{seconds} seconds" if seconds.positive? || parts.empty?
+        parts.join(', ')
+      else
+        format('%<d>02d:%<h>02d:%<m>02d:%<s>02d', d: days, h: hours, m: minutes, s: seconds)
+      end
+    end
   end
 end