na 1.2.87 → 1.2.88

data/bin/commands/next.rb

@@ -83,6 +83,22 @@ class App
     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
 
@@ -262,6 +278,55 @@ 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],

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

@@ -83,6 +83,22 @@ class App
     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]
 
@@ -184,6 +200,53 @@ class App
                 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,

data/bin/commands/update.rb

@@ -9,6 +9,21 @@ 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
@@ -329,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> "'
@@ -441,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
@@ -453,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(/^@/, '') } : []

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

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]

data/lib/na/next_action.rb

@@ -3,6 +3,98 @@
 # Next Action methods
 module NA
   class << self
+    # Select actions across files using existing search pipeline
+    # @return [Array<NA::Action>]
+    def select_actions(file: nil, depth: 1, search: [], tagged: [], include_done: false)
+      files = if file
+                [file]
+              else
+                find_files(depth: depth)
+              end
+      out = []
+      files.each do |f|
+        _projects, actions = find_actions(f, search, tagged, done: include_done, all: true)
+        out.concat(actions) if actions
+      end
+      out
+    end
+
+    # Apply a plugin result hash back to the underlying file
+    # - Move if parents changed (project path differs)
+    # - Update text/note/tags
+    def apply_plugin_result(io_hash)
+      file = io_hash['file_path']
+      line = io_hash['line'].to_i
+      parents = Array(io_hash['parents']).map(&:to_s)
+      text = io_hash['text'].to_s
+      note = io_hash['note'].to_s
+      tags = Array(io_hash['tags']).to_h { |t| [t['name'].to_s, t['value'].to_s] }
+      action_block = io_hash['action'] || { 'action' => 'UPDATE', 'arguments' => [] }
+      action_name = action_block['action'].to_s.upcase
+      action_args = Array(action_block['arguments'])
+
+      # Load current action
+      _projects, actions = find_actions(file, nil, nil, all: true, done: true, project: nil, search_note: true, target_line: line)
+      action = actions&.first
+      return unless action
+
+      # Determine new project path from parents array
+      new_project = ''
+      new_parent_chain = []
+      if parents.any?
+        new_project = parents.first.to_s
+        new_parent_chain = parents[1..] || []
+      end
+
+      case action_name
+      when 'DELETE'
+        update_action(file, { target_line: line }, delete: true, all: true)
+        return
+      when 'COMPLETE'
+        update_action(file, { target_line: line }, finish: true, all: true)
+        return
+      when 'RESTORE'
+        update_action(file, { target_line: line }, restore: true, all: true)
+        return
+      when 'ARCHIVE'
+        update_action(file, { target_line: line }, finish: true, move: 'Archive', all: true)
+        return
+      when 'ADD_TAG'
+        add_tags = action_args.map { |t| t.sub(/^@/, '') }
+        update_action(file, { target_line: line }, add: action, add_tag: add_tags, all: true)
+        return
+      when 'DELETE_TAG', 'REMOVE_TAG'
+        remove_tags = action_args.map { |t| t.sub(/^@/, '') }
+        update_action(file, { target_line: line }, add: action, remove_tag: remove_tags, all: true)
+        return
+      when 'MOVE'
+        move_to = action_args.first.to_s
+        update_action(file, { target_line: line }, add: action, move: move_to, all: true)
+        return
+      end
+
+      # Replace content on the existing action then write back in-place
+      original_line = action.file_line
+      action.action = text
+      action.note = note.to_s.split("\n")
+      action.action.gsub!(/(?<=\A| )@\S+(?:\(.*?\))?/, '')
+      unless tags.empty?
+        tag_str = tags.map { |k, v| v.to_s.empty? ? "@#{k}" : "@#{k}(#{v})" }.join(' ')
+        action.action = action.action.strip + (tag_str.empty? ? "" : " #{tag_str}")
+      end
+      # Ensure we update this exact action in-place
+      update_action(file, { target_line: original_line }, add: action, all: true)
+
+      # If parents changed, set move target
+      move_to = nil
+      move_to = ([new_project] + new_parent_chain).join(':') if new_project.to_s.strip != action.project || new_parent_chain != action.parent
+
+      update_action(file, nil,
+                    add: action,
+                    project: action.project,
+                    overwrite: true,
+                    move: move_to)
+    end
     include NA::Editor
 
     attr_accessor :verbose, :extension, :include_ext, :na_tag, :command_line, :command, :globals, :global_file,