na 1.2.85 → 1.2.87

data/lib/na/next_action.rb

@@ -169,8 +169,9 @@ module NA
     # @param done [Boolean] Include done actions
     # @param project [String, nil] Project name
     # @param search_note [Boolean] Search notes
+    # @param target_line [Integer] Specific line number to target
     # @return [Array] Projects and actions
-    def find_actions(target, search, tagged = nil, all: false, done: false, project: nil, search_note: true)
+    def find_actions(target, search, tagged = nil, all: false, done: false, project: nil, search_note: true, target_line: nil)
       todo = NA::Todo.new({ search: search,
                             search_note: search_note,
                             require_na: false,
@@ -187,7 +188,17 @@ module NA
 
       return [todo.projects, todo.actions] if todo.actions.count == 1 || all
 
-      options = todo.actions.map { |action| "#{action.line} % #{action.parent.join('/')} : #{action.action}" }
+      # If target_line is specified, find the action at that specific line
+      if target_line
+        matching_action = todo.actions.find { |a| a.line == target_line }
+        return [todo.projects, NA::Actions.new([matching_action])] if matching_action
+
+        NA.notify("#{NA.theme[:error]}No action found at line #{target_line}", exit_code: 1)
+        return [todo.projects, NA::Actions.new]
+
+      end
+
+      options = todo.actions.map { |action| "#{action.file} : #{action.action}" }
       res = choose_from(options, prompt: 'Make a selection: ', multiple: true, sorted: true)
 
       unless res&.length&.positive?
@@ -197,9 +208,14 @@ module NA
 
       selected = NA::Actions.new
       res.each do |result|
-        idx = result.match(/^(\d+)(?= % )/)[1]
-        action = todo.actions.select { |a| a.line == idx.to_i }.first
-        selected.push(action)
+        # Extract file:line from result (e.g., "./todo.taskpaper:21 : action text")
+        match = result.match(/^(.+?):(\d+) : /)
+        next unless match
+
+        file_path = match[1]
+        line_num = match[2].to_i
+        action = todo.actions.select { |a| a.file_path == file_path && a.file_line == line_num }.first
+        selected.push(action) if action
       end
       [todo.projects, selected]
     end
@@ -311,7 +327,25 @@ module NA
                       move: nil,
                       remove_tag: [],
                       replace: nil,
-                      tagged: nil)
+                      tagged: nil,
+                      started_at: nil,
+                      done_at: nil,
+                      duration_seconds: nil)
+      # Coerce date/time inputs if passed as strings
+      begin
+        started_at = NA::Types.parse_date_begin(started_at) if started_at && !started_at.is_a?(Time)
+      rescue StandardError
+        # leave as-is
+      end
+      begin
+        done_at = NA::Types.parse_date_end(done_at) if done_at && !done_at.is_a?(Time)
+      rescue StandardError
+        # leave as-is
+      end
+      NA.notify("UPDATE parsed started_at=#{started_at.inspect} done_at=#{done_at.inspect} duration=#{duration_seconds.inspect}", debug: true)
+      # Expand target to absolute path to avoid path resolution issues
+      target = File.expand_path(target) unless Pathname.new(target).absolute?
+
       projects = find_projects(target)
       affected_actions = []
 
@@ -336,13 +370,24 @@ module NA
       contents = target.read_file.split("\n")
 
       if add.is_a?(Action)
-        add_tag ||= []
-        add.process(priority: priority, finish: finish, add_tag: add_tag, remove_tag: remove_tag)
+        # NOTE: Edit is handled in the update command before calling update_action
+        # So we don't need to handle it here - the action is already edited
 
-        # Remove the original action and its notes
-        action_line = add.line
+        add_tag ||= []
+        NA.notify("PROCESS before add.process started_at=#{started_at.inspect} done_at=#{done_at.inspect}", debug: true)
+        add.process(priority: priority,
+                    finish: finish,
+                    add_tag: add_tag,
+                    remove_tag: remove_tag,
+                    started_at: started_at,
+                    done_at: done_at,
+                    duration_seconds: duration_seconds)
+        NA.notify("PROCESS after add.process action=\"#{add.action}\"", debug: true)
+
+        # Remove the original action and its notes if this is an existing action
+        action_line = add.file_line
         note_lines = add.note.is_a?(Array) ? add.note.count : 0
-        contents.slice!(action_line, note_lines + 1)
+        contents.slice!(action_line, note_lines + 1) if action_line.is_a?(Integer)
 
         # Prepare updated note
         note = note.to_s.split("\n") unless note.is_a?(Array)
@@ -362,59 +407,94 @@ module NA
         # Format note for insertion
         note_str = updated_note.empty? ? '' : "\n#{indent}\t\t#{updated_note.join("\n#{indent}\t\t").strip}"
 
-        # Insert at correct location: if moving, insert at start/end of target project
-        if move && target_proj
-          insert_line = if append
-                          # End of project
-                          target_proj.last_line + 1
-                        else
-                          # Start of project (after project header)
-                          target_proj.line + 1
-                        end
-          contents.insert(insert_line, "#{indent}\t- #{add.action}#{note_str}")
+        # If delete was requested in this direct update path, do not re-insert
+        if delete
+          affected_actions << { action: add, desc: 'deleted' }
         else
-          # Not moving, update in-place
-          contents.insert(action_line, "#{indent}\t- #{add.action}#{note_str}")
-        end
+          # Insert at correct location
+          if target_proj
+            insert_line = if append
+                            # End of project
+                            target_proj.last_line + 1
+                          else
+                            # Start of project (after project header)
+                            target_proj.line + 1
+                          end
+            # Ensure @started tag persists if provided
+            final_action = add.action.dup
+            if started_at && final_action !~ /(?<=\A| )@start(?:ed)?\(/i
+              final_action = final_action.gsub(/(?<=\A| )@start(?:ed)?\(.*?\)/i, '').strip
+              final_action = "#{final_action} @started(#{started_at.strftime('%Y-%m-%d %H:%M')})"
+            end
+            NA.notify("INSERT at #{insert_line} final_action=\"#{final_action}\"", debug: true)
+            contents.insert(insert_line, "#{indent}\t- #{final_action}#{note_str}")
+          else
+            # Fallback: append to end of file
+            final_action = add.action.dup
+            if started_at && final_action !~ /(?<=\A| )@start(?:ed)?\(/i
+              final_action = final_action.gsub(/(?<=\A| )@start(?:ed)?\(.*?\)/i, '').strip
+              final_action = "#{final_action} @started(#{started_at.strftime('%Y-%m-%d %H:%M')})"
+            end
+            NA.notify("APPEND final_action=\"#{final_action}\"", debug: true)
+            contents << "#{indent}\t- #{final_action}#{note_str}"
+          end
 
-        notify(add.pretty)
+          notify(add.pretty)
+        end
 
         # Track affected action and description
-        changes = ['updated']
-        changes << 'finished' if finish
-        changes << "priority=#{priority}" if priority.to_i.positive?
-        changes << "tags+#{add_tag.join(',')}" unless add_tag.nil? || add_tag.empty?
-        changes << "tags-#{remove_tag.join(',')}" unless remove_tag.nil? || remove_tag.empty?
-        changes << 'note updated' unless note.nil? || note.empty?
-        changes << "moved to #{target_proj.project}" if move && target_proj
-        affected_actions << { action: add, desc: changes.join(', ') }
+        unless delete
+          changes = ['updated']
+          changes << 'finished' if finish
+          changes << "priority=#{priority}" if priority.to_i.positive?
+          changes << "tags+#{add_tag.join(',')}" unless add_tag.nil? || add_tag.empty?
+          changes << "tags-#{remove_tag.join(',')}" unless remove_tag.nil? || remove_tag.empty?
+          changes << 'note updated' unless note.nil? || note.empty?
+          changes << "moved to #{target_proj.project}" if move && target_proj
+          affected_actions << { action: add, desc: changes.join(', ') }
+        end
       else
+        # Check if search is actually target_line
+        target_line = search.is_a?(Hash) && search[:target_line] ? search[:target_line] : nil
         _, actions = find_actions(target, search, tagged, done: done, all: all, project: project,
-                                                          search_note: search_note)
+                                                          search_note: search_note, target_line: target_line)
 
         return if actions.nil?
 
-        actions.sort_by(&:line).reverse.each do |action|
-          contents.slice!(action.line, action.note.count + 1)
+        # Handle edit (single or multi-action)
+        if edit
+          editor_content = Editor.format_multi_action_input(actions)
+          edited_content = Editor.fork_editor(editor_content)
+          edited_actions = Editor.parse_multi_action_output(edited_content)
+
+          # Map edited content back to actions
+          actions.each do |action|
+            # Use file_path:file_line as the key
+            key = "#{action.file_path}:#{action.file_line}"
+            action.action, action.note = edited_actions[key] if edited_actions[key]
+          end
+        end
+
+        actions.sort_by(&:file_line).reverse.each do |action|
+          contents.slice!(action.file_line, action.note.count + 1)
           if delete
             # Track deletion before skipping re-insert
             affected_actions << { action: action, desc: 'deleted' }
             next
           end
 
-          projects = shift_index_after(projects, action.line, action.note.count + 1)
-
-          if edit
-            editor_content = "#{action.action}\n#{action.note.join("\n")}"
-            new_action, new_note = Editor.format_input(Editor.fork_editor(editor_content))
-            action.action = new_action
-            action.note = new_note
-          end
+          projects = shift_index_after(projects, action.file_line, action.note.count + 1)
 
           # If replace is defined, use search to search and replace text in action
           action.action.sub!(Regexp.new(Regexp.escape(search), Regexp::IGNORECASE), replace) if replace
 
-          action.process(priority: priority, finish: finish, add_tag: add_tag, remove_tag: remove_tag)
+          action.process(priority: priority,
+                         finish: finish,
+                         add_tag: add_tag,
+                         remove_tag: remove_tag,
+                         started_at: started_at,
+                         done_at: done_at,
+                         duration_seconds: duration_seconds)
 
           target_proj = if target_proj
                           projects.select { |proj| proj.project =~ /^#{target_proj.project}$/ }.first
@@ -501,7 +581,7 @@ module NA
     # @param finish [Boolean] Mark as finished
     # @param append [Boolean] Append to project
     # @return [void]
-    def add_action(file, project, action, note = [], priority: 0, finish: false, append: false)
+    def add_action(file, project, action, note = [], priority: 0, finish: false, append: false, started_at: nil, done_at: nil, duration_seconds: nil)
       parent = project.split(%r{[:/]})
 
       if NA.global_file
@@ -514,8 +594,16 @@ module NA
 
       action = Action.new(file, project, parent, action, nil, note)
 
-      update_action(file, nil, add: action, project: project, add_tag: add_tag, priority: priority, finish: finish,
-                               append: append)
+      update_action(file, nil,
+                    add: action,
+                    project: project,
+                    add_tag: add_tag,
+                    priority: priority,
+                    finish: finish,
+                    append: append,
+                    started_at: started_at,
+                    done_at: done_at,
+                    duration_seconds: duration_seconds)
     end
 
     # Build a nested hash representing project hierarchy from actions

data/lib/na/string.rb

@@ -149,13 +149,17 @@ class ::String
   # @param color [String] The highlight color template
   # @param last_color [String] Color to restore after highlight
   def highlight_search(regexes, color: NA.theme[:search_highlight], last_color: NA.theme[:action])
+    # Skip if string already contains ANSI codes - applying regex to colored text
+    # will break escape sequences (e.g., searching for "3" will match "3" in "38;2;236;204;135m")
+    return self if include?("\e")
+
+    # Original simple approach for strings without ANSI codes
     string = dup
     color = NA::Color.template(color.dup)
     regexes.each do |rx|
       next if rx.nil?
 
       rx = Regexp.new(rx, Regexp::IGNORECASE) if rx.is_a?(String)
-
       string.gsub!(rx) do
         m = Regexp.last_match
         last = m.pre_match.last_color
@@ -185,14 +189,14 @@ class ::String
   # @param indent [Integer] Number of spaces to indent each line
   # @return [String] Wrapped string
   def wrap(width, indent)
-    return "\n#{self}" if width <= 80
+    return to_s if width.nil? || width <= 0
 
     output = []
     line = []
     length = 0
-    gsub!(/(@\S+)\((.*?)\)/) { "#{Regexp.last_match(1)}(#{Regexp.last_match(2).gsub(/ /, '†')})" }
+    text = gsub(/(@\S+)\((.*?)\)/) { "#{Regexp.last_match(1)}(#{Regexp.last_match(2).gsub(/ /, '†')})" }
 
-    split(' ').each do |word|
+    text.split.each do |word|
       uncolored = NA::Color.uncolor(word)
       if (length + uncolored.length + 1) <= width
         line << word
@@ -306,7 +310,14 @@ class ::String
       m = Regexp.last_match
       t = m['tag']
       d = m['date']
-      future = t =~ /^(done|complete)/ ? false : true
+      # Determine whether to bias toward future or past parsing
+      # Non-done tags usually bias to future, except explicit past phrases like "ago", "yesterday", or "last ..."
+      explicit_past = d =~ /(\bago\b|yesterday|\blast\b)/i
+      future = if t =~ /^(done|complete)/
+                 false
+               else
+                 explicit_past ? false : true
+               end
       parsed_date = d =~ iso_rx ? Time.parse(d) : d.chronify(guess: :begin, future: future)
       parsed_date.nil? ? m[0] : "@#{t}(#{parsed_date.strftime('%F %R')})"
     end

data/lib/na/theme.rb

@@ -37,51 +37,61 @@ module NA
       # @example
       #   NA::Theme.load_theme(template: { action: '{r}' })
       def load_theme(template: {})
-        NA::Benchmark.measure('Theme.load_theme') do
-          # Default colorization, can be overridden with full or partial template variable
-          default_template = {
-            parent: '{c}',
-            bracket: '{dc}',
-            parent_divider: '{xw}/',
-            action: '{bg}',
-            project: '{xbk}',
-            tags: '{m}',
-            value_parens: '{m}',
-            values: '{c}',
-            search_highlight: '{y}',
-            note: '{dw}',
-            dirname: '{xdw}',
-            filename: '{xb}{#eccc87}',
-            prompt: '{m}',
-            success: '{bg}',
-            error: '{b}{#b61d2a}',
-            warning: '{by}',
-            debug: '{dw}',
-            templates: {
-              output: '%filename%parents| %action',
-              default: '%parent%action',
-              single_file: '%parent%action',
-              multi_file: '%filename%parent%action',
-              no_file: '%parent%action'
-            }
-          }
+        if defined?(NA::Benchmark) && NA::Benchmark
+          NA::Benchmark.measure('Theme.load_theme') do
+            load_theme_internal(template: template)
+          end
+        else
+          load_theme_internal(template: template)
+        end
+      end
 
-          # Load custom theme
-          theme_file = NA.database_path(file: 'theme.yaml')
-          theme = if File.exist?(theme_file)
-                    YAML.load(File.read(theme_file)) || {}
-                  else
-                    {}
-                  end
-          theme = default_template.deep_merge(theme)
+      def load_theme_internal(template: {})
+        # Default colorization, can be overridden with full or partial template variable
+        default_template = {
+          parent: '{c}',
+          bracket: '{dc}',
+          parent_divider: '{xw}/',
+          action: '{bg}',
+          project: '{xbk}',
+          tags: '{m}',
+          value_parens: '{m}',
+          values: '{c}',
+          duration: '{y}',
+          search_highlight: '{y}',
+          note: '{dw}',
+          dirname: '{xdw}',
+          filename: '{xb}{#eccc87}',
+          line: '{dw}',
+          prompt: '{m}',
+          success: '{bg}',
+          error: '{b}{#b61d2a}',
+          warning: '{by}',
+          debug: '{dw}',
+          templates: {
+            output: '%filename%line%parents| %action',
+            default: '%parents %line %action',
+            single_file: '%parents %line %action',
+            multi_file: '%filename%line%parents %action',
+            no_file: '%parents %line %action'
+          }
+        }
 
-          File.open(theme_file, 'w') do |f|
-            f.puts template_help.comment
-            f.puts YAML.dump(theme)
-          end
+        # Load custom theme
+        theme_file = NA.database_path(file: 'theme.yaml')
+        theme = if File.exist?(theme_file)
+                  YAML.load(File.read(theme_file)) || {}
+                else
+                  {}
+                end
+        theme = default_template.deep_merge(theme)
 
-          theme.merge(template)
+        File.open(theme_file, 'w') do |f|
+          f.puts template_help.comment
+          f.puts YAML.dump(theme)
         end
+
+        theme.merge(template)
       end
     end
   end

data/lib/na/types.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'na/string'
+
+module NA
+  # Custom types for GLI
+  # Provides natural language date/time and duration parsing
+  # Uses chronify gem for parsing
+  module Types
+    module_function
+
+    # Normalize shorthand relative durations to phrases Chronic can parse.
+    # Examples:
+    #  - "30m ago"    => "30 minutes ago"
+    #  - "-30m"       => "30 minutes ago"
+    #  - "2h30m"      => "2 hours 30 minutes ago" (when default_past)
+    #  - "2h 30m ago" => "2 hours 30 minutes ago"
+    #  - "2:30 ago"   => "2 hours 30 minutes ago"
+    #  - "-2:30"      => "2 hours 30 minutes ago"
+    # Accepts d,h,m units; hours:minutes pattern; optional leading '-'; optional 'ago'.
+    # @param value [String] the duration string to normalize
+    # @param default_past [Boolean] whether to default to past tense
+    # @return [String] the normalized duration string
+    def normalize_relative_duration(value, default_past: false)
+      return value if value.nil?
+
+      s = value.to_s.strip
+      return s if s.empty?
+
+      has_ago = s =~ /\bago\b/i
+      negative = s.start_with?('-')
+
+      text = s.sub(/^[-+]/, '')
+
+      # hours:minutes pattern (e.g., 2:30, 02:30)
+      if (m = text.match(/^(\d{1,2}):(\d{1,2})(?:\s*ago)?$/i))
+        hours = m[1].to_i
+        minutes = m[2].to_i
+        parts = []
+        parts << "#{hours} hours" if hours.positive?
+        parts << "#{minutes} minutes" if minutes.positive?
+        return "#{parts.join(' ')} ago"
+      end
+
+      # Compound d/h/m (order independent, allow spaces): e.g., 1d2h30m, 2h 30m, 30m
+      days = hours = minutes = 0
+      found = false
+      if (dm = text.match(/(?:(\d+)\s*d)/i))
+        days = dm[1].to_i
+        found = true
+      end
+      if (hm = text.match(/(?:(\d+)\s*h)/i))
+        hours = hm[1].to_i
+        found = true
+      end
+      if (mm = text.match(/(?:(\d+)\s*m)/i))
+        minutes = mm[1].to_i
+        found = true
+      end
+
+      if found
+        parts = []
+        parts << "#{days} days" if days.positive?
+        parts << "#{hours} hours" if hours.positive?
+        parts << "#{minutes} minutes" if minutes.positive?
+        # Determine if we should make it past-tense
+        return "#{parts.join(' ')} ago" if negative || has_ago || default_past
+
+        return parts.join(' ')
+
+      end
+
+      # Fall through: not a shorthand we handle
+      s
+    end
+
+    # Parse a natural-language/iso date string for a start time
+    # @param value [String] the date string to parse
+    # @return [Time] the parsed date, or nil if parsing fails
+    def parse_date_begin(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      # Prefer explicit ISO first (only if the value looks ISO-like)
+      iso_rx = /\A\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?\z/
+      if value.to_s.strip =~ iso_rx
+        begin
+          return Time.parse(value)
+        rescue StandardError
+          # fall through to chronify
+        end
+      end
+
+      # Fallback to chronify with guess begin
+      begin
+        # Normalize shorthand (e.g., 2h30m, -2:30, 30m ago)
+        txt = normalize_relative_duration(value.to_s, default_past: true)
+        # Bias to past for expressions like "ago", "yesterday", or "last ..."
+        future = txt !~ /(\bago\b|yesterday|\blast\b)/i
+        result = txt.chronify(guess: :begin, future: future)
+        NA.notify("Parsed '#{value}' as #{result}", debug: true) if result
+        result
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Parse a natural-language/iso date string for an end time
+    # @param value [String] the date string to parse
+    # @return [Time] the parsed date, or nil if parsing fails
+    def parse_date_end(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      # Prefer explicit ISO first (only if the value looks ISO-like)
+      iso_rx = /\A\d{4}-\d{2}-\d{2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?\z/
+      if value.to_s.strip =~ iso_rx
+        begin
+          return Time.parse(value)
+        rescue StandardError
+          # fall through to chronify
+        end
+      end
+
+      # Fallback to chronify with guess end
+      value.to_s.chronify(guess: :end, future: false)
+    end
+
+    # Convert duration expressions to seconds
+    # Supports: "90" (minutes), "45m", "2h", "1d2h30m", with optional leading '-' or trailing 'ago'
+    # Also supports "2:30", "2:30 ago", and word forms like "2 hours 30 minutes (ago)"
+    # @param value [String] the duration string to parse
+    # @return [Integer] the duration in seconds, or nil if parsing fails
+    def parse_duration_seconds(value)
+      return nil if value.nil?
+
+      s = value.to_s.strip
+      return nil if s.empty?
+
+      # Strip leading sign and optional 'ago'
+      s = s.sub(/^[-+]/, '')
+      s = s.sub(/\bago\b/i, '').strip
+
+      # H:MM pattern
+      m = s.match(/^(\d{1,2}):(\d{1,2})$/)
+      if m
+        hours = m[1].to_i
+        minutes = m[2].to_i
+        return (hours * 3600) + (minutes * 60)
+      end
+
+      # d/h/m compact with letters, order independent (e.g., 1d2h30m, 2h 30m, 30m)
+      m = s.match(/^(?:(?<day>\d+)\s*d)?\s*(?:(?<hour>\d+)\s*h)?\s*(?:(?<min>\d+)\s*m)?$/i)
+      if m && !m[0].strip.empty? && (m['day'] || m['hour'] || m['min'])
+        return [[m['day'], 86_400], [m['hour'], 3600], [m['min'], 60]].map { |q, mult| q ? q.to_i * mult : 0 }.sum
+      end
+
+      # Word forms: e.g., "2 hours 30 minutes", "1 day 2 hours", etc.
+      days = 0
+      hours = 0
+      minutes = 0
+      found_word = false
+      if (dm = s.match(/(\d+)\s*(?:day|days)\b/i))
+        days = dm[1].to_i
+        found_word = true
+      end
+      if (hm = s.match(/(\d+)\s*(?:hour|hours|hr|hrs)\b/i))
+        hours = hm[1].to_i
+        found_word = true
+      end
+      if (mm = s.match(/(\d+)\s*(?:minute|minutes|min|mins)\b/i))
+        minutes = mm[1].to_i
+        found_word = true
+      end
+      return (days * 86_400) + (hours * 3600) + (minutes * 60) if found_word
+
+      # Plain number => minutes
+      return s.to_i * 60 if s =~ /^\d+$/
+
+      # Last resort: try chronify two points and take delta
+      begin
+        start = Time.now
+        finish = s.chronify(context: 'now', guess: :end, future: false)
+        return (finish - start).abs.to_i if finish
+      rescue StandardError
+        # ignore
+      end
+
+      nil
+    end
+  end
+end

data/lib/na/version.rb

@@ -5,5 +5,5 @@
 module Na
   ##
   # Current version of the na gem.
-  VERSION = '1.2.85'
+  VERSION = '1.2.87'
 end

data/lib/na.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
 
-require 'na/benchmark'
+require 'na/benchmark' if ENV['NA_BENCHMARK']
+# Define a dummy Benchmark if not available for tests
+unless defined?(NA::Benchmark)
+  module NA
+    module Benchmark
+      def self.measure(_label)
+        yield
+      end
+    end
+  end
+end
 require 'na/version'
 require 'na/pager'
 require 'time'
@@ -21,6 +31,7 @@ require 'na/todo'
 require 'na/actions'
 require 'na/project'
 require 'na/action'
+require 'na/types'
 require 'na/editor'
 require 'na/next_action'
 require 'na/prompt'