na 1.2.85 → 1.2.87

data/lib/na/action.rb

@@ -14,7 +14,12 @@ module NA
     def initialize(file, project, parent, action, idx, note = [])
       super()
 
-      @file = file
+      # Store file in PATH:LINE format if line is available
+      @file = if idx.is_a?(Integer)
+                "#{file}:#{idx}"
+              else
+                file
+              end
       @project = project
       @parent = parent
       @action = action.gsub('{', '\\{')
@@ -23,6 +28,32 @@ module NA
       @note = note
     end
 
+    # Extract file path and line number from PATH:LINE format
+    #
+    # @return [Array] [file_path, line_number]
+    def file_line_parts
+      if @file.to_s.include?(':')
+        path, line = @file.split(':', 2)
+        [path, line.to_i]
+      else
+        [@file, @line]
+      end
+    end
+
+    # Get just the file path without line number
+    #
+    # @return [String] File path
+    def file_path
+      file_line_parts.first
+    end
+
+    # Get the line number
+    #
+    # @return [Integer] Line number
+    def file_line
+      file_line_parts.last
+    end
+
     # Update the action string and note with priority, tags, and completion status
     #
     # @param priority [Integer] Priority value to set
@@ -32,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?
@@ -53,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
 
@@ -70,7 +124,7 @@ module NA
              else
                ''
              end
-      "(#{@file}:#{@line}) #{@project}:#{@parent.join('>')} | #{@action}#{note}"
+      "(#{file_path}:#{file_line}) #{@project}:#{@parent.join(">")} | #{@action}#{note}"
     end
 
     # Pretty string representation of the action with color formatting
@@ -82,7 +136,7 @@ module NA
              else
                ''
              end
-      "{x}#{NA.theme[:filename]}#{File.basename(@file)}:#{@line}{x}#{NA.theme[:bracket]}[{x}#{NA.theme[:project]}#{@project}:#{@parent.join('>')}{x}#{NA.theme[:bracket]}]{x} | #{NA.theme[:action]}#{@action}{x}#{NA.theme[:note]}#{note}"
+      "{x}#{NA.theme[:filename]}#{File.basename(file_path)}:#{file_line}{x}#{NA.theme[:bracket]}[{x}#{NA.theme[:project]}#{@project}:#{@parent.join('>')}{x}#{NA.theme[:bracket]}]{x} | #{NA.theme[:action]}#{@action}{x}#{NA.theme[:note]}#{note}"
     end
 
     # Inspect the action object
@@ -112,49 +166,67 @@ module NA
       NA::Benchmark.measure('Action.pretty') do
         # Use cached theme instead of loading every time
         theme = NA.theme
-        template = theme.merge(template)
+        # Merge templates if provided
+        if template[:templates]
+          theme = theme.dup
+          theme[:templates] = theme[:templates].merge(template[:templates])
+          template = theme.merge(template.reject { |k| k == :templates })
+        else
+          template = theme.merge(template)
+        end
 
         # Pre-compute common template parts to avoid repeated processing
         output_template = template[:templates][:output]
         needs_filename = output_template.include?('%filename')
+        needs_line = output_template.include?('%line')
         needs_parents = output_template.include?('%parents') || output_template.include?('%parent')
         needs_project = output_template.include?('%project')
 
         # Create the hierarchical parent string (optimized)
         parents = if needs_parents && @parent.any?
                     parent_parts = @parent.map { |par| "#{template[:parent]}#{par}" }.join(template[:parent_divider])
-                    NA::Color.template("{x}#{template[:bracket]}[#{template[:error]}#{parent_parts}{x}#{template[:bracket]}]{x} ")
+                    # parent_parts already has color codes embedded, create final string directly
+                    "#{NA::Color.template("{x}#{template[:bracket]}[")}#{parent_parts}#{NA::Color.template("{x}#{template[:bracket]}]{x}")}"
                   else
                     ''
                   end
 
-        # Create the project string (optimized)
+        # Create the project string (optimized) - Ensure color reset before project
         project = if needs_project && !@project.empty?
-                    NA::Color.template("{x}#{template[:project]}#{@project}{x} ")
+                    NA::Color.template("{x}#{template[:project]}#{@project}{x}")
                   else
                     ''
                   end
 
         # Create the source filename string (optimized)
         filename = if needs_filename
-                     path = @file ? @file.sub(%r{^\./}, '').sub(/#{Dir.home}/, '~') : ''
+                     path_only = file_path # Extract just the path from PATH:LINE
+                     path = path_only.sub(%r{^\./}, '').sub(/#{Dir.home}/, '~')
                      if File.dirname(path) == '.'
                        fname = NA.include_ext ? File.basename(path) : File.basename(path, ".#{extension}")
                        fname = "./#{fname}" if NA.show_cwd_indicator
-                       NA::Color.template("#{template[:filename]}#{fname} {x}")
+                       NA::Color.template("#{template[:filename]}#{fname}{x}")
                      else
                        colored = (NA.include_ext ? path : path.sub(/\.#{extension}$/, '')).highlight_filename
-                       NA::Color.template("#{template[:filename]}#{colored} {x}")
+                       NA::Color.template("#{template[:filename]}#{colored}{x}")
                      end
                    else
                      ''
                    end
 
+        # Create the line number string (optimized)
+        line_num = if needs_line && @line
+                     NA::Color.template("#{template[:line]}:#{@line} {x}")
+                   else
+                     ''
+                   end
+
         # colorize the action and highlight tags (optimized)
         action_text = @action.dup
         action_text.gsub!(/\{(.*?)\}/, '\\{\1\\}')
         action_text = action_text.sub(/ @#{NA.na_tag}\b/, '')
-        action = NA::Color.template("#{template[:action]}#{action_text}{x}")
+        # Reset colors before action to prevent bleeding from parents/project
+        action = NA::Color.template("{x}#{template[:action]}#{action_text}{x}")
         action = action.highlight_tags(color: template[:tags],
                                        parens: template[:value_parens],
                                        value: template[:values],
@@ -169,8 +241,8 @@ module NA
               width = @cached_width ||= TTY::Screen.columns
               # Calculate indent more efficiently - avoid repeated template processing
               base_template = output_template.gsub('%action', '').gsub('%note', '')
-              base_output = base_template.gsub('%filename', filename).gsub('%project', project).gsub(/%parents?/,
-                                                                                                     parents)
+              base_output = base_template.gsub('%filename', filename).gsub('%line', line_num).gsub('%project', project).gsub(/%parents?/,
+                                                                                                                             parents)
               indent = NA::Color.uncolor(NA::Color.template(base_output)).length
               note = NA::Color.template(@note.wrap(width, indent, template[:note]))
             else
@@ -185,7 +257,7 @@ module NA
         if detect_width && !action.empty?
           width = @cached_width ||= TTY::Screen.columns
           base_template = output_template.gsub('%action', '').gsub('%note', '')
-          base_output = base_template.gsub('%filename', filename).gsub('%project', project).gsub(/%parents?/, parents)
+          base_output = base_template.gsub('%filename', filename).gsub('%line', line_num).gsub('%project', project).gsub(/%parents?/, parents)
           indent = NA::Color.uncolor(NA::Color.template(base_output)).length
           action = action.wrap(width, indent)
         end
@@ -193,6 +265,7 @@ module NA
         # Replace variables in template string and output colorized (optimized)
         final_output = output_template.dup
         final_output.gsub!('%filename', filename)
+        final_output.gsub!('%line', line_num)
         final_output.gsub!('%project', project)
         final_output.gsub!(/%parents?/, parents)
         final_output.gsub!('%action', action.highlight_search(regexes))

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

data/lib/na/editor.rb

@@ -100,7 +100,12 @@ module NA
           tmpfile.unlink
         end
 
-        input.split("\n").delete_if(&:ignore?).join("\n")
+        # Don't strip comments if this looks like multi-action format (has # ------ markers)
+        if input.include?('# ------ ')
+          input
+        else
+          input.split("\n").delete_if(&:ignore?).join("\n")
+        end
       end
 
       # Takes a multi-line string and formats it as an entry
@@ -129,6 +134,80 @@ module NA
 
         [title, note]
       end
+
+      # Format multiple actions for multi-edit
+      # @param actions [Array<Action>] Actions to edit
+      # @return [String] Formatted editor content
+      def format_multi_action_input(actions)
+        header = <<~EOF
+          # Instructions:
+          # - Edit the action text (the lines WITHOUT # comment markers)
+          # - DO NOT remove or edit the lines starting with "# ------"
+          # - Add notes on new lines after the action
+          # - Blank lines are ignored
+          #
+
+        EOF
+
+        # Use + to create a mutable string
+        content = +header
+
+        actions.each do |action|
+          # Use file_path to get the path and file_line to get the line number
+          content << "# ------ #{action.file_path}:#{action.file_line}\n"
+          content << "#{action.action}\n"
+          content << "#{action.note.join("\n")}\n" if action.note.any?
+          content << "\n" # Blank line separator
+        end
+
+        content
+      end
+
+      # Parse multi-action editor output
+      # @param content [String] Editor output
+      # @return [Hash] Hash mapping file:line to [action, note]
+      def parse_multi_action_output(content)
+        results = {}
+        current_file = nil
+        current_action = nil
+        current_note = []
+
+        content.lines.each do |line|
+          stripped = line.strip
+
+          # Check for file marker: # ------ path:line
+          match = stripped.match(/^# ------ (.+?):(\d+)$/)
+          if match
+            # Save previous action if exists
+            results[current_file] = [current_action, current_note] if current_file && current_action
+
+            # Start new action
+            current_file = "#{match[1]}:#{match[2]}"
+            current_action = nil
+            current_note = []
+            next
+          end
+
+          # Skip other comment lines
+          next if stripped.start_with?('#')
+
+          # Skip blank lines
+          next if stripped.empty?
+
+          # Store as action or note based on what we've seen so far
+          if current_action.nil?
+            current_action = stripped
+          else
+            # Subsequent lines are notes
+            current_note << stripped
+          end
+        end
+
+        # Save last action
+        results[current_file] = [current_action, current_note] if current_file && current_action
+
+        results
+      end
     end
   end
 end