na 1.2.86 → 1.2.88

data/bin/commands/update.rb

@@ -9,6 +9,32 @@ class App
   allow you to pick which file to act on.'
   arg_name 'ACTION'
   command %i[update] do |c|
+    c.desc 'Run a plugin by name on selected actions'
+    c.arg_name 'NAME'
+    c.flag %i[plugin]
+
+    c.desc 'Plugin input format (json|yaml|csv|text)'
+    c.arg_name 'TYPE'
+    c.flag %i[input]
+
+    c.desc 'Plugin output format (json|yaml|csv|text)'
+    c.arg_name 'TYPE'
+    c.flag %i[output]
+
+    c.desc 'Divider string for text IO'
+    c.arg_name 'STRING'
+    c.flag %i[divider]
+    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 +325,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
@@ -315,6 +344,17 @@ class App
           { key: :archive, label: 'Archive', param: nil },
           { key: :note, label: 'Add Note', param: 'Note' }
         ]
+        # Append available plugins
+        begin
+          NA::Plugins.ensure_plugins_home
+          NA::Plugins.list_plugins.each do |_key, path|
+            meta = NA::Plugins.parse_plugin_metadata(path)
+            disp = meta['name'] || File.basename(path, File.extname(path))
+            actions_menu << { key: :_plugin, label: "Plugin: #{disp}", param: nil, plugin_path: path }
+          end
+        rescue StandardError
+          # ignore plugin discovery errors in menu
+        end
         selector = nil
         if TTY::Which.exist?('fzf')
           selector = 'fzf --prompt="Select action> "'
@@ -361,6 +401,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
@@ -412,6 +467,9 @@ class App
         when :note
           options[:note] = true
           note = [param_value]
+        when :_plugin
+          # Set plugin path directly
+          options[:plugin] = action_obj[:plugin_path]
         end
       end
       did_direct_update = false
@@ -424,7 +482,31 @@ class App
         actions_by_file[file] << targets_for_selection[idx][:action]
       end
 
-      # Process each file's actions
+      # If a plugin is specified, run it on all selected actions and apply results
+      if options[:plugin]
+        plugin_path = options[:plugin]
+        unless File.exist?(plugin_path)
+          # Resolve by name via registry
+          resolved = NA::Plugins.resolve_plugin(plugin_path)
+          plugin_path = resolved if resolved
+        end
+        meta = NA::Plugins.parse_plugin_metadata(plugin_path)
+        input_fmt = (options[:input] || meta['input'] || 'json').to_s
+        output_fmt = (options[:output] || meta['output'] || input_fmt).to_s
+        divider = (options[:divider] || '||')
+
+        all_actions = []
+        actions_by_file.each_value { |list| all_actions.concat(list) }
+        io_actions = all_actions.map(&:to_plugin_io_hash)
+        stdin_str = NA::Plugins.serialize_actions(io_actions, format: input_fmt, divider: divider)
+        stdout = NA::Plugins.run_plugin(plugin_path, stdin_str)
+        returned = NA::Plugins.parse_actions(stdout, format: output_fmt, divider: divider)
+        Array(returned).each { |h| NA.apply_plugin_result(h) }
+        did_direct_update = true
+        next
+      end
+
+      # Process each file's actions (non-plugin paths)
       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(/^@/, '') } : []
@@ -477,8 +559,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 +721,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

@@ -113,6 +113,7 @@ class App
 
   pre do |global, _command, _options, _args|
     NA.move_deprecated_backups
+    NA::Plugins.ensure_plugins_home
     NA.verbose = global[:debug]
     NA::Pager.paginate = global[:pager] && $stdout.isatty
     NA::Color.coloring = global[:color] && $stdout.isatty
@@ -195,6 +196,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

@@ -28,6 +28,19 @@ module NA
       @note = note
     end
 
+    # Convert action to plugin IO hash
+    # @return [Hash]
+    def to_plugin_io_hash
+      {
+        'file_path' => file_path,
+        'line' => file_line,
+        'parents' => [@project].concat(@parent),
+        'text' => @action.dup,
+        'note' => @note.join("\n"),
+        'tags' => @tags.map { |k, v| { 'name' => k, 'value' => (v || '').to_s } }
+      }
+    end
+
     # Extract file path and line number from PATH:LINE format
     #
     # @return [Array] [file_path, line_number]
@@ -63,8 +76,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 +97,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