na 1.2.86 → 1.2.88

data/bin/commands/complete.rb

@@ -5,6 +5,17 @@ class App
   desc 'Find and mark an action as @done'
   arg_name 'ACTION'
   command %i[complete finish] 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 complete "An existing task"',
               desc: 'Find "An existing task" and mark @done'
     c.example 'na finish "An existing task"',

data/bin/commands/find.rb

@@ -29,6 +29,12 @@ class App
     c.desc "Include notes in output"
     c.switch %i[notes], negatable: true, default_value: false
 
+    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 "Include notes in search"
     c.switch %i[search_notes], negatable: true, default_value: true
 
@@ -62,6 +68,22 @@ class App
     c.desc "Output actions nested by file and project"
     c.switch %[omnifocus], negatable: false
 
+    c.desc 'Run a plugin on results (STDOUT only; no file writes)'
+    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.action do |global_options, options, args|
       options[:nest] = true if options[:omnifocus]
 
@@ -169,13 +191,61 @@ class App
           [tokens]
         end
 
+      # Plugin piping (display-only)
+      if options[:plugin]
+        NA::Plugins.ensure_plugins_home
+        plugin_path = options[:plugin]
+        unless File.exist?(plugin_path)
+          resolved = NA::Plugins.resolve_plugin(plugin_path)
+          plugin_path = resolved if resolved
+        end
+        if plugin_path && File.exist?(plugin_path)
+          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] || '||')
+
+          io_actions = todo.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 = Array(NA::Plugins.parse_actions(stdout, format: output_fmt, divider: divider))
+          index = {}
+          todo.actions.each { |a| index["#{a.file_path}:#{a.file_line}"] = a }
+          returned.each do |h|
+            key = "#{h['file_path']}:#{h['line'].to_i}"
+            a = index[key]
+            next unless a
+            new_text = h['text'].to_s
+            new_note = h['note'].to_s
+            new_tags = Array(h['tags']).map { |t| [t['name'].to_s, t['value'].to_s] }
+            new_text = new_text.gsub(/(?<=\A| )@\S+(?:\(.*?\))?/, '')
+            unless new_tags.empty?
+              tag_str = new_tags.map { |k, v| v.to_s.empty? ? "@#{k}" : "@#{k}(#{v})" }.join(' ')
+              new_text = new_text.strip + (tag_str.empty? ? '' : " #{tag_str}")
+            end
+            a.action = new_text
+            a.note = new_note.empty? ? [] : new_note.split("\n")
+            a.instance_variable_set(:@tags, a.scan_tags)
+            parents = Array(h['parents']).map(&:to_s)
+            if parents.any?
+              new_proj = parents.first.to_s
+              new_chain = parents[1..] || []
+              a.instance_variable_set(:@project, new_proj)
+              a.parent = new_chain
+            end
+          end
+        end
+      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] })
     end
   end
 end

data/bin/commands/next.rb

@@ -65,9 +65,40 @@ class App
     c.desc "Include notes in output"
     c.switch %i[notes], negatable: true, default_value: false
 
+    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 "Include @done actions"
     c.switch %i[done]
 
+    c.desc "Run a plugin on results (STDOUT only; no file writes)"
+    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 "Output actions nested by file"
     c.switch %i[nest], negatable: false
 
@@ -189,7 +220,20 @@ class App
         end
       end
 
-      options[:done] = true if tags.any? { |tag| tag[:tag] =~ /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
+        options[:done] = true if tags.any? { |tag| tag[:tag] =~ /done/ }
+      end
 
       search_tokens = nil
       if options[:exact]
@@ -234,12 +278,66 @@ class App
                   Run `na todos` to see available todo files.")
       end
       NA::Pager.paginate = false if options[:omnifocus]
+
+      # If a plugin is specified, transform actions in memory for display only
+      if options[:plugin]
+        NA::Plugins.ensure_plugins_home
+        plugin_path = options[:plugin]
+        unless File.exist?(plugin_path)
+          resolved = NA::Plugins.resolve_plugin(plugin_path)
+          plugin_path = resolved if resolved
+        end
+        if plugin_path && File.exist?(plugin_path)
+          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] || '||')
+
+          io_actions = todo.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 = Array(NA::Plugins.parse_actions(stdout, format: output_fmt, divider: divider))
+          index = {}
+          todo.actions.each { |a| index["#{a.file_path}:#{a.file_line}"] = a }
+          returned.each do |h|
+            key = "#{h['file_path']}:#{h['line'].to_i}"
+            a = index[key]
+            next unless a
+            # Update for display: text, note, tags
+            new_text = h['text'].to_s
+            new_note = h['note'].to_s
+            new_tags = Array(h['tags']).map { |t| [t['name'].to_s, t['value'].to_s] }
+            # replace tags in text
+            new_text = new_text.gsub(/(?<=\A| )@\S+(?:\(.*?\))?/, '')
+            unless new_tags.empty?
+              tag_str = new_tags.map { |k, v| v.to_s.empty? ? "@#{k}" : "@#{k}(#{v})" }.join(' ')
+              new_text = new_text.strip + (tag_str.empty? ? '' : " #{tag_str}")
+            end
+            a.action = new_text
+            a.note = new_note.empty? ? [] : new_note.split("\n")
+            a.instance_variable_set(:@tags, a.scan_tags)
+            # parents -> possibly change project and parent chain for display
+            parents = Array(h['parents']).map(&:to_s)
+            if parents.any?
+              new_proj = parents.first.to_s
+              new_chain = parents[1..] || []
+              a.instance_variable_set(:@project, new_proj)
+              a.parent = new_chain
+            end
+          end
+        end
+      end
       todo.actions.output(depth,
                           { files: todo.files,
                             nest: options[:nest],
                             nest_projects: options[:omnifocus],
                             notes: options[:notes],
-                            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/plugin.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class App
+  extend GLI::App
+
+  desc 'Run a plugin on selected actions'
+  arg_name 'NAME'
+  command %i[plugin] do |c|
+    c.desc 'Input format (json|yaml|text)'
+    c.arg_name 'TYPE'
+    c.flag %i[input]
+
+    c.desc 'Output format (json|yaml|text)'
+    c.arg_name 'TYPE'
+    c.flag %i[output]
+
+    c.desc 'Text divider when using --input/--output text'
+    c.arg_name 'STRING'
+    c.flag %i[divider]
+
+    c.desc 'Specify the file to search for the task'
+    c.arg_name 'PATH'
+    c.flag %i[file in]
+
+    c.desc 'Search for files X directories deep'
+    c.arg_name 'DEPTH'
+    c.flag %i[d depth], must_match: /^[1-9]$/, type: :integer, default_value: 1
+
+    c.desc 'Filter results using search terms'
+    c.arg_name 'QUERY'
+    c.flag %i[search find grep], multiple: true
+
+    c.desc 'Include @done actions'
+    c.switch %i[done]
+
+    c.desc 'Match actions containing tag. Allows value comparisons'
+    c.arg_name 'TAG'
+    c.flag %i[tagged], multiple: true
+
+    c.action do |_global, options, args|
+      plugin_name = args.first
+      NA.notify("#{NA.theme[:error]}Plugin name required", exit_code: 1) unless plugin_name
+
+      NA::Plugins.ensure_plugins_home
+      path = NA::Plugins.resolve_plugin(plugin_name)
+      NA.notify("#{NA.theme[:error]}Plugin not found: #{plugin_name}", exit_code: 1) unless path
+
+      meta = NA::Plugins.parse_plugin_metadata(path)
+      input_fmt = (options[:input] || meta['input'] || 'json').to_s
+      output_fmt = (options[:output] || meta['output'] || input_fmt).to_s
+      divider = (options[:divider] || '||')
+
+      # Build selection using the same plumbing as update/find
+      actions = NA.select_actions(
+        file: options[:file],
+        depth: options[:depth],
+        search: options[:search],
+        tagged: options[:tagged],
+        include_done: options[:done]
+      )
+
+      io_actions = actions.map(&:to_plugin_io_hash)
+      stdin_str = NA::Plugins.serialize_actions(io_actions, format: input_fmt, divider: divider)
+      stdout = NA::Plugins.run_plugin(path, stdin_str)
+      returned = NA::Plugins.parse_actions(stdout, format: output_fmt, divider: divider)
+
+      # Apply updates
+      returned.each do |h|
+        NA.apply_plugin_result(h)
+      end
+    end
+  end
+end
+
+

data/bin/commands/tagged.rb

@@ -2,124 +2,168 @@
 
 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.desc 'Run a plugin on results (STDOUT only; no file writes)'
+    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.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 +176,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 +196,69 @@ class App
                             require_na: false })
 
       regexes = if tokens.is_a?(Array)
-          tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
-        else
-          [tokens]
+                  tokens.delete_if { |token| token[:negate] }.map { |token| token[:token] }
+                else
+                  [tokens]
+                end
+
+      # Plugin piping (display only)
+      if options[:plugin]
+        NA::Plugins.ensure_plugins_home
+        plugin_path = options[:plugin]
+        unless File.exist?(plugin_path)
+          resolved = NA::Plugins.resolve_plugin(plugin_path)
+          plugin_path = resolved if resolved
         end
+        if plugin_path && File.exist?(plugin_path)
+          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] || '||')
+
+          io_actions = todo.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 = Array(NA::Plugins.parse_actions(stdout, format: output_fmt, divider: divider))
+          index = {}
+          todo.actions.each { |a| index["#{a.file_path}:#{a.file_line}"] = a }
+          returned.each do |h|
+            key = "#{h['file_path']}:#{h['line'].to_i}"
+            a = index[key]
+            next unless a
+            new_text = h['text'].to_s
+            new_note = h['note'].to_s
+            new_tags = Array(h['tags']).map { |t| [t['name'].to_s, t['value'].to_s] }
+            new_text = new_text.gsub(/(?<=\A| )@\S+(?:\(.*?\))?/, '')
+            unless new_tags.empty?
+              tag_str = new_tags.map { |k, v| v.to_s.empty? ? "@#{k}" : "@#{k}(#{v})" }.join(' ')
+              new_text = new_text.strip + (tag_str.empty? ? '' : " #{tag_str}")
+            end
+            a.action = new_text
+            a.note = new_note.empty? ? [] : new_note.split("\n")
+            a.instance_variable_set(:@tags, a.scan_tags)
+            parents = Array(h['parents']).map(&:to_s)
+            if parents.any?
+              new_proj = parents.first.to_s
+              new_chain = parents[1..] || []
+              a.instance_variable_set(:@project, new_proj)
+              a.parent = new_chain
+            end
+          end
+        end
+      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