na 1.2.86 → 1.2.88

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,
@@ -327,7 +419,22 @@ 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?
 
@@ -359,12 +466,20 @@ module NA
         # So we don't need to handle it here - the action is already edited
 
         add_tag ||= []
-        add.process(priority: priority, finish: finish, add_tag: add_tag, remove_tag: remove_tag)
-
-        # Remove the original action and its notes
+        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)
@@ -384,32 +499,52 @@ 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
@@ -445,7 +580,13 @@ module NA
           # 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
@@ -532,7 +673,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
@@ -545,8 +686,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/plugins.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+require 'csv'
+
+module NA
+  # Plugins module for NA
+  module Plugins
+    module_function
+
+    def plugins_home
+      File.expand_path('~/.local/share/na/plugins')
+    end
+
+    def ensure_plugins_home
+      dir = plugins_home
+      return if File.directory?(dir)
+
+      FileUtils.mkdir_p(dir)
+      readme = File.join(dir, 'README.md')
+      File.write(readme, default_readme_contents) unless File.exist?(readme)
+      create_sample_plugins(dir)
+    end
+
+    def list_plugins
+      dir = plugins_home
+      return {} unless File.directory?(dir)
+
+      Dir.children(dir).each_with_object({}) do |entry, acc|
+        path = File.join(dir, entry)
+        next unless File.file?(path)
+        next if entry =~ /\.(md|bak)$/i
+        next unless shebang?(path)
+
+        base = File.basename(entry, File.extname(entry))
+        key = base.gsub(/[\s_]/, '')
+        acc[key.downcase] = path
+      end
+    end
+
+    def resolve_plugin(name)
+      return nil unless name && !name.to_s.strip.empty?
+
+      normalized = name.to_s.strip.gsub(/[\s_]/, '').downcase
+      candidates = list_plugins
+      return candidates[normalized] if candidates.key?(normalized)
+
+      # Fallback: try exact filename match in dir
+      path = File.join(plugins_home, name)
+      File.file?(path) ? path : nil
+    end
+
+    def shebang_for(file)
+      first = begin
+        File.open(file, 'r', &:readline)
+      rescue StandardError
+        ''
+      end
+      first.start_with?('#!') ? first.sub('#!', '').strip : nil
+    end
+
+    def parse_plugin_metadata(file)
+      meta = { 'input' => nil, 'output' => nil, 'name' => nil }
+      lines = File.readlines(file, chomp: true)
+      return meta if lines.empty?
+
+      # skip shebang
+      i = 0
+      i += 1 if lines[0].to_s.start_with?('#!')
+      # skip leading blanks
+      i += 1 while i < lines.length && lines[i].strip.empty?
+      while i < lines.length
+        line = lines[i]
+        break if line.strip.empty?
+
+        # strip common comment leaders
+        stripped = line.sub(%r{^\s*(#|//)}, '').strip
+        if (m = stripped.match(/^([A-Za-z]+)\s*:\s*(.+)$/))
+          key = m[1].downcase
+          val = m[2].strip
+          case key
+          when 'input', 'output'
+            meta[key] = val.downcase
+          when 'name', 'title'
+            meta['name'] = val
+          end
+        end
+        break if meta.values_at('input', 'output', 'name').compact.size == 3
+
+        i += 1
+      end
+      meta
+    end
+
+    def run_plugin(file, stdin_str)
+      interp = shebang_for(file)
+      cmd = interp ? %(#{interp} #{Shellwords.escape(file)}) : %(sh #{Shellwords.escape(file)})
+      IO.popen(cmd, 'r+', err: %i[child out]) do |io|
+        io.write(stdin_str.to_s)
+        io.close_write
+        io.read
+      end
+    end
+
+    def serialize_actions(actions, format: 'json', divider: '||')
+      case format.to_s.downcase
+      when 'json'
+        JSON.pretty_generate(actions)
+      when 'yaml', 'yml'
+        YAML.dump(actions)
+      when 'csv'
+        CSV.generate(force_quotes: true) do |csv|
+          csv << %w[action arguments file_path line parents text note tags]
+          actions.each do |a|
+            csv << [
+              (a['action'] && a['action']['action']) || 'UPDATE',
+              Array(a['action'] && a['action']['arguments']).join(','),
+              a['file_path'],
+              a['line'],
+              Array(a['parents']).join('>'),
+              a['text'] || '',
+              a['note'] || '',
+              serialize_tags(a['tags'])
+            ]
+          end
+        end
+      when 'text', 'txt'
+        actions.map { |a| serialize_text(a, divider: divider) }.join("\n")
+      else
+        JSON.generate(actions)
+      end
+    end
+
+    def parse_actions(str, format: 'json', divider: '||')
+      case format.to_s.downcase
+      when 'json'
+        JSON.parse(str)
+      when 'yaml', 'yml'
+        YAML.safe_load(str, permitted_classes: [Time], aliases: true)
+      when 'csv'
+        rows = CSV.parse(str.to_s, headers: true)
+        rows = CSV.parse(str.to_s) if rows.nil? || rows.empty?
+        rows.map do |row|
+          r = if row.is_a?(CSV::Row)
+                row.to_h
+              else
+                {
+                  'action' => row[0], 'arguments' => row[1], 'file_path' => row[2], 'line' => row[3],
+                  'parents' => row[4], 'text' => row[5], 'note' => row[6], 'tags' => row[7]
+                }
+              end
+          {
+            'file_path' => r['file_path'].to_s,
+            'line' => r['line'].to_i,
+            'parents' => (r['parents'].to_s.empty? ? [] : r['parents'].split('>').map(&:strip)),
+            'text' => r['text'].to_s,
+            'note' => r['note'].to_s,
+            'tags' => parse_tags(r['tags']),
+            'action' => normalize_action_block(r['action'], r['arguments'])
+          }
+        end
+      when 'text', 'txt'
+        str.to_s.split(/\r?\n/).reject(&:empty?).map { |line| parse_text(line, divider: divider) }
+      end
+    end
+
+    def serialize_text(action, divider: '||')
+      parts = []
+      act = action['action'] && action['action']['action']
+      args = Array(action['action'] && action['action']['arguments']).join(',')
+      parts << (act || 'UPDATE')
+      parts << args
+      parts << "#{action['file_path']}:#{action['line']}"
+      parts << Array(action['parents']).join('>')
+      parts << (action['text'] || '')
+      parts << (action['note'] || '').gsub("\n", '\\n')
+      parts << serialize_tags(action['tags'])
+      parts.join(divider)
+    end
+
+    def parse_text(line, divider: '||')
+      tokens = line.split(divider, 7)
+      action_token = tokens[0].to_s.strip
+      if action_name?(action_token)
+        act = action_token
+        args = tokens[1]
+        fileline = tokens[2]
+        parents = tokens[3]
+        text = tokens[4]
+        note = tokens[5]
+        tags = tokens[6]
+      else
+        act = 'UPDATE'
+        args = ''
+        fileline = tokens[0]
+        parents = tokens[1]
+        text = tokens[2]
+        note = tokens[3]
+        tags = tokens[4]
+      end
+      fp, ln = (fileline || '').split(':', 2)
+      {
+        'file_path' => fp.to_s,
+        'line' => ln.to_i,
+        'parents' => (parents.to_s.empty? ? [] : parents.split('>').map(&:strip)),
+        'text' => text.to_s,
+        'note' => note.to_s.gsub('\\n', "\n"),
+        'tags' => parse_tags(tags),
+        'action' => normalize_action_block(act, args)
+      }
+    end
+
+    def serialize_tags(tags)
+      Array(tags).map { |t| t['value'].to_s.empty? ? t['name'].to_s : %(#{t['name']}(#{t['value']})) }.join(';')
+    end
+
+    def parse_tags(str)
+      return [] if str.to_s.strip.empty?
+
+      str.split(';').map do |part|
+        if (m = part.match(/^([^()]+)\((.*)\)$/))
+          { 'name' => m[1].strip, 'value' => m[2].to_s }
+        else
+          { 'name' => part.strip, 'value' => '' }
+        end
+      end
+    end
+
+    def shebang?(file)
+      first = begin
+        File.open(file, 'r', &:readline)
+      rescue StandardError
+        ''
+      end
+      first.start_with?('#!')
+    end
+
+    def action_name?(name)
+      return false if name.to_s.strip.empty?
+
+      %w[update delete complete finish restore unfinish archive add_tag delete_tag remove_tag move].include?(name.to_s.downcase)
+    end
+
+    def normalize_action_block(action_name, args)
+      name = (action_name || 'UPDATE').to_s.upcase
+      name = 'DELETE_TAG' if name == 'REMOVE_TAG'
+      name = 'COMPLETE' if name == 'FINISH'
+      name = 'RESTORE' if name == 'UNFINISH'
+      {
+        'action' => name,
+        'arguments' => args.is_a?(Array) ? args : args.to_s.split(/[,;]/).map(&:strip).reject(&:empty?)
+      }
+    end
+
+    def default_readme_contents
+      <<~MD
+        # NA Plugins
+
+        Put your scripts in this folder. Each plugin must start with a shebang (#!) so NA knows how to execute it.
+
+        - Plugins receive input on STDIN and must write output to STDOUT
+        - Do not modify the original files; NA applies changes based on your output
+        - Do not change `file_path` or `line` in your output
+        - You may change `parents` (to move), `text`, `note`, and `tags`
+
+        ## Metadata (optional)
+        Add a comment block (after the shebang) with key: value pairs to declare defaults. Keys are case-insensitive.
+
+        ```
+        # input: json
+        # output: json
+        # name: My Fancy Plugin
+        ```
+
+        CLI flags `--input/--output/--divider` override metadata when provided.
+
+        ## Formats
+        Valid input/output formats: `json`, `yaml`, `csv`, `text`.
+
+        Text format line:
+        ```
+        ACTION||ARGS||file_path:line||parents||text||note||tags
+        ```
+        - If the first token isn’t a known ACTION, it’s treated as `file_path:line` and ACTION defaults to `UPDATE`.
+        - `parents`: `Parent>Child>Leaf`
+        - `tags`: `name(value);name;other(value)`
+
+        JSON/YAML object schema per action:
+        ```json
+        {
+          "action": { "action": "UPDATE", "arguments": ["arg1"] },
+          "file_path": "/path/to/todo.taskpaper",
+          "line": 15,
+          "parents": ["Project", "Subproject"],
+          "text": "- Do something @tag(value)",
+          "note": "Notes can\nspan lines",
+          "tags": [ { "name": "tag", "value": "value" } ]
+        }
+        ```
+
+        ACTION values (case-insensitive): `UPDATE` (default), `DELETE`, `COMPLETE`/`FINISH`, `RESTORE`/`UNFINISH`, `ARCHIVE`, `ADD_TAG`, `DELETE_TAG`/`REMOVE_TAG`, `MOVE`.
+        - For `ADD_TAG`, `DELETE_TAG`/`REMOVE_TAG`, and `MOVE`, provide arguments (e.g., tags or target project).
+
+        ## Examples
+
+        JSON input example (2 actions):
+        ```json
+        [
+          {
+            "file_path": "/projects/todo.taskpaper",
+            "line": 21,
+            "parents": ["Inbox"],
+            "text": "- Example action",
+            "note": "",
+            "tags": []
+          },
+          {
+            "file_path": "/projects/todo.taskpaper",
+            "line": 42,
+            "parents": ["Work", "Feature"],
+            "text": "- Add feature @na",
+            "note": "Spec TKT-123",
+            "tags": [{"name":"na","value":""}]
+          }
+        ]
+        ```
+
+        Text input example (2 actions):
+        ```
+        UPDATE||||/projects/todo.taskpaper:21||Inbox||- Example action||||
+        MOVE||Work:NewFeature||/projects/todo.taskpaper:42||Work>Feature||- Add feature @na||Spec TKT-123||na
+        ```
+
+        A plugin would read from STDIN, transform, and write the same shape to STDOUT. For example, a shell plugin that adds `@bar`:
+        ```bash
+        #!/usr/bin/env bash
+        # input: text
+        # output: text
+        while IFS= read -r line; do
+          [[ -z "$line" ]] && continue
+          IFS='||' read -r a1 a2 a3 a4 a5 a6 a7 <<<"$line"
+          # If first token is not an action, treat it as file:line
+          case "${a1^^}" in
+            UPDATE|DELETE|COMPLETE|FINISH|RESTORE|UNFINISH|ARCHIVE|ADD_TAG|DELETE_TAG|REMOVE_TAG|MOVE) : ;;
+            *) a7="$a6"; a6="$a5"; a5="$a4"; a4="$a3"; a3="$a2"; a2=""; a1="UPDATE";;
+          esac
+          tags="$a7"; tags=${tags:+"$tags;bar"}; tags=${tags:-bar}
+          echo "$a1||$a2||$a3||$a4||$a5||$a6||$tags"
+        done
+        ```
+
+        Python example (JSON):
+        ```python
+        #!/usr/bin/env python3
+        # input: json
+        # output: json
+        import sys, json, time
+        data = json.load(sys.stdin)
+        for a in data:
+            act = a.get('action') or {'action':'UPDATE','arguments':[]}
+            a['action'] = act
+            tags = a.get('tags', [])
+            tags.append({'name':'foo','value':time.strftime('%Y-%m-%d %H:%M:%S')})
+            a['tags'] = tags
+        json.dump(data, sys.stdout)
+        ```
+
+        Tips:
+        - Always preserve `file_path` and `line`
+        - Return only actions you want changed; others can be omitted
+        - For text IO, the field divider defaults to `||` and can be overridden with `--divider`
+      MD
+    end
+
+    def create_sample_plugins(dir)
+      py = File.join(dir, 'Add Foo.py')
+      sh = File.join(dir, 'Add Bar.sh')
+      unless File.exist?(py)
+        File.write(py, <<~PY)
+          #!/usr/bin/env python3
+          # name: Add Foo
+          # input: json
+          # output: json
+          import sys, json, time
+          data = json.load(sys.stdin)
+          now = time.strftime('%Y-%m-%d %H:%M:%S')
+          for a in data:
+              tags = a.get('tags', [])
+              tags.append({'name':'foo','value':now})
+              a['tags'] = tags
+          json.dump(data, sys.stdout)
+        PY
+      end
+      return if File.exist?(sh)
+
+      File.write(sh, <<~SH)
+        #!/usr/bin/env bash
+        # name: Add Bar
+        # input: text
+        # output: text
+        while IFS= read -r line; do
+          if [[ -z "$line" ]]; then continue; fi
+          if [[ "$line" == *"||"* ]]; then
+            fileline=${line%%||*}
+            rest=${line#*||}
+            parents=${rest%%||*}; rest=${rest#*||}
+            text=${rest%%||*}; rest=${rest#*||}
+            note=${rest%%||*}; tags=${rest#*||}
+            if [[ -z "$tags" ]]; then tags="bar"; else tags="$tags;bar"; fi
+            echo "$fileline||$parents||$text||$note||$tags"
+          else
+            echo "$line"
+          fi
+        done
+      SH
+    end
+  end
+end