na 1.2.88 → 1.2.89

data/lib/na/next_action.rb

@@ -69,12 +69,16 @@ module NA
         return
       when 'MOVE'
         move_to = action_args.first.to_s
-        update_action(file, { target_line: line }, add: action, move: move_to, all: true)
+        update_action(file, { target_line: line }, add: action, move: move_to, all: true, suppress_prompt: true)
         return
       end
 
       # Replace content on the existing action then write back in-place
       original_line = action.file_line
+      original_project = action.project
+      original_parent_chain = action.parent.dup
+
+      # Update action content
       action.action = text
       action.note = note.to_s.split("\n")
       action.action.gsub!(/(?<=\A| )@\S+(?:\(.*?\))?/, '')
@@ -82,18 +86,13 @@ module NA
         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
+      # Check if parents changed
+      parents_changed = new_project.to_s.strip != original_project || new_parent_chain != original_parent_chain
+      move_to = parents_changed ? ([new_project] + new_parent_chain).join(':') : nil
 
-      update_action(file, nil,
-                    add: action,
-                    project: action.project,
-                    overwrite: true,
-                    move: move_to)
+      # Update in-place (with move if parents changed)
+      update_action(file, { target_line: original_line }, add: action, move: move_to, all: true, suppress_prompt: true)
     end
     include NA::Editor
 
@@ -143,6 +142,7 @@ module NA
     # @return     [Boolean] result
     #
     def yn(prompt, default: true)
+      return default if ENV['NA_TEST'] == '1'
       return default unless $stdout.isatty
 
       tty_state = `stty -g`
@@ -422,7 +422,8 @@ module NA
                       tagged: nil,
                       started_at: nil,
                       done_at: nil,
-                      duration_seconds: nil)
+                      duration_seconds: nil,
+                      suppress_prompt: false)
       # 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)
@@ -447,14 +448,19 @@ module NA
         move = move.sub(/:$/, '')
         target_proj = projects.select { |pr| pr.project =~ /#{move.gsub(':', '.*?:.*?')}/i }.first
         if target_proj.nil?
-          res = NA.yn(
-            NA::Color.template("#{NA.theme[:warning]}Project #{NA.theme[:file]}#{move}#{NA.theme[:warning]} doesn't exist, add it"), default: true
-          )
-          if res
-            target_proj = insert_project(target, move, projects)
+          if suppress_prompt || !$stdout.isatty
+            target_proj = insert_project(target, move)
             projects << target_proj
           else
-            NA.notify("#{NA.theme[:error]}Cancelled", exit_code: 1)
+            res = NA.yn(
+              NA::Color.template("#{NA.theme[:warning]}Project #{NA.theme[:file]}#{move}#{NA.theme[:warning]} doesn't exist, add it"), default: true
+            )
+            if res
+              target_proj = insert_project(target, move)
+              projects << target_proj
+            else
+              NA.notify("#{NA.theme[:error]}Cancelled", exit_code: 1)
+            end
           end
         end
       end

data/lib/na/plugins.rb

@@ -13,14 +13,43 @@ module NA
       File.expand_path('~/.local/share/na/plugins')
     end
 
-    def ensure_plugins_home
+    def plugins_disabled_home
+      File.expand_path('~/.local/share/na/plugins_disabled')
+    end
+
+    def samples_generated_flag
+      File.expand_path('~/.local/share/na/.samples_generated')
+    end
+
+    def samples_generated?
+      File.exist?(samples_generated_flag)
+    end
+
+    def mark_samples_generated
+      FileUtils.mkdir_p(File.dirname(samples_generated_flag))
+      File.write(samples_generated_flag, Time.now.iso8601) unless File.exist?(samples_generated_flag)
+    end
+
+    def ensure_plugins_home(force_samples: false)
       dir = plugins_home
-      return if File.directory?(dir)
+      dis = plugins_disabled_home
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      FileUtils.mkdir_p(dis) unless File.directory?(dis)
 
-      FileUtils.mkdir_p(dir)
       readme = File.join(dir, 'README.md')
       File.write(readme, default_readme_contents) unless File.exist?(readme)
-      create_sample_plugins(dir)
+
+      return if samples_generated? || force_samples
+
+      create_sample_plugins(dis)
+      mark_samples_generated
+    end
+
+    def generate_sample_plugins
+      dis = plugins_disabled_home
+      FileUtils.mkdir_p(dis) unless File.directory?(dis)
+      create_sample_plugins(dis, force: true)
+      mark_samples_generated
     end
 
     def list_plugins
@@ -39,6 +68,22 @@ module NA
       end
     end
 
+    def list_plugins_disabled
+      dir = plugins_disabled_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?
 
@@ -48,6 +93,10 @@ module NA
 
       # Fallback: try exact filename match in dir
       path = File.join(plugins_home, name)
+      return path if File.file?(path)
+
+      # Also check disabled folder
+      path = File.join(plugins_disabled_home, name)
       File.file?(path) ? path : nil
     end
 
@@ -60,6 +109,17 @@ module NA
       first.start_with?('#!') ? first.sub('#!', '').strip : nil
     end
 
+    def infer_shebang_for_extension(ext)
+      case ext.downcase
+      when '.rb' then '#!/usr/bin/env ruby'
+      when '.py' then '#!/usr/bin/env python3'
+      when '.zsh' then '#!/usr/bin/env zsh'
+      when '.fish' then '#!/usr/bin/env fish'
+      when '.js', '.mjs' then '#!/usr/bin/env node'
+      else '#!/usr/bin/env bash'
+      end
+    end
+
     def parse_plugin_metadata(file)
       meta = { 'input' => nil, 'output' => nil, 'name' => nil }
       lines = File.readlines(file, chomp: true)
@@ -103,6 +163,64 @@ module NA
       end
     end
 
+    def enable_plugin(name)
+      # Try by resolved path; if already enabled, return
+      path = resolve_plugin(name)
+      return path if path && File.dirname(path) == plugins_home
+
+      # Find in disabled by normalized name
+      disabled_map = Dir.exist?(plugins_disabled_home) ? Dir.children(plugins_disabled_home) : []
+      from = disabled_map.map { |e| File.join(plugins_disabled_home, e) }
+                         .find { |p| File.basename(p).downcase.start_with?(name.to_s.downcase) }
+      from ||= File.join(plugins_disabled_home, name)
+      to = File.join(plugins_home, File.basename(from))
+      FileUtils.mv(from, to)
+      to
+    end
+
+    def disable_plugin(name)
+      path = resolve_plugin(name)
+      return path if path && File.dirname(path) == plugins_disabled_home
+
+      enabled_map = Dir.exist?(plugins_home) ? Dir.children(plugins_home) : []
+      from = enabled_map.map { |e| File.join(plugins_home, e) }
+                        .find { |p| File.basename(p).downcase.start_with?(name.to_s.downcase) }
+      from ||= File.join(plugins_home, name)
+      to = File.join(plugins_disabled_home, File.basename(from))
+      FileUtils.mv(from, to)
+      to
+    end
+
+    def create_plugin(name, language: nil)
+      base = File.basename(name)
+      ext = File.extname(base)
+      if ext.empty? && language
+        ext = language.start_with?('.') ? language : ".#{language.split('/').last}"
+      end
+      ext = '.sh' if ext.empty?
+      she = language&.start_with?('/') ? language : infer_shebang_for_extension(ext)
+      file = File.join(plugins_home, base.sub(File.extname(base), '') + ext)
+      content = []
+      content << she
+      content << "# name: #{base.sub(File.extname(base), '')}"
+      content << '# input: json'
+      content << '# output: json'
+      content << '# New plugin template'
+      content << ''
+      content << '# Read STDIN and echo back unchanged'
+      content << 'if command -v python3 >/dev/null 2>&1; then'
+      content << "  python3 - \"$@\" <<'PY'"
+      content << 'import sys, json'
+      content << 'data = json.load(sys.stdin)'
+      content << 'json.dump(data, sys.stdout)'
+      content << 'PY'
+      content << 'else'
+      content << '  cat'
+      content << 'fi'
+      File.write(file, content.join("\n"))
+      file
+    end
+
     def serialize_actions(actions, format: 'json', divider: '||')
       case format.to_s.downcase
       when 'json'
@@ -373,10 +491,12 @@ module NA
       MD
     end
 
-    def create_sample_plugins(dir)
+    def create_sample_plugins(dir, force: false)
       py = File.join(dir, 'Add Foo.py')
       sh = File.join(dir, 'Add Bar.sh')
-      unless File.exist?(py)
+
+      if force || !File.exist?(py)
+        FileUtils.rm_f(py)
         File.write(py, <<~PY)
           #!/usr/bin/env python3
           # name: Add Foo
@@ -392,8 +512,32 @@ module NA
           json.dump(data, sys.stdout)
         PY
       end
-      return if File.exist?(sh)
+      unless 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
+
+      return unless force || !File.exist?(sh)
 
+      FileUtils.rm_f(sh)
       File.write(sh, <<~SH)
         #!/usr/bin/env bash
         # name: Add Bar
@@ -414,6 +558,7 @@ module NA
           fi
         done
       SH
+      File.chmod(0o755, sh)
     end
   end
 end

data/lib/na/version.rb

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

data/src/_README.md

@@ -9,7 +9,50 @@
 _If you're one of the rare people like me who find this useful, feel free to
 [buy me some coffee][donate]._
 
-The current version of `na` is <!--VER-->1.2.87<!--END VER-->.
+The current version of `na` is <!--VER-->1.2.88<!--END VER-->.
+
+<!--GITHUB-->
+### Table of contents
+
+- [Installation](#installation)
+- [Optional Dependencies](#optional-dependencies)
+- [Features](#features)
+  - [Easy matching](#easy-matching)
+  - [Recursion](#recursion)
+  - [Adding todos](#adding-todos)
+  - [Updating todos](#updating-todos)
+- [Terminology](#terminology)
+- [Usage](#usage)
+  - [Commands](#commands)
+  - [add](#add)
+  - [edit](#edit)
+  - [find](#find)
+  - [init, create](#init-create)
+  - [move](#move)
+  - [next, show](#next-show)
+  - [plugin](#plugin)
+  - [projects](#projects)
+  - [saved](#saved)
+  - [scan](#scan)
+  - [tagged](#tagged)
+  - [todos](#todos)
+  - [update](#update)
+  - [changelog](#changelog)
+  - [complete](#complete)
+  - [archive](#archive)
+  - [tag](#tag)
+  - [undo](#undo)
+- [Configuration](#configuration)
+  - [Working with a single global file](#working-with-a-single-global-file)
+  - [Add tasks at the end of a project](#add-tasks-at-the-end-of-a-project)
+  - [Prompt Hooks](#prompt-hooks)
+- [Time tracking](#time-tracking)
+- [Plugins](#plugins)
+- [Changelog](#changelog)
+<!--END GITHUB--><!--JEKYLL
+- Table of Contents
+{:.toc}
+-->
 
 `na` ("next action") is a command line tool designed to make it easy to see what your next actions are for any project, right from the command line. It works with TaskPaper-formatted files (but any plain text format will do), looking for `@na` tags (or whatever you specify) in todo files in your current folder.
 
@@ -140,6 +183,54 @@ To see all next actions across all known todos, use `na next "*"`. You can combi
 @cli(bundle exec bin/na help next)
 ```
 
+##### plugin
+
+Manage and run external plugins. See also the Plugins section below.
+
+```
+@cli(bundle exec bin/na help plugin)
+```
+
+###### plugin new
+
+Create a new plugin script (aliases: `n`). Infers shebang by extension or `--language`.
+
+```
+@cli(bundle exec bin/na help plugin new)
+```
+
+###### plugin edit
+
+Open an existing plugin in your default editor. Prompts if no name is given.
+
+```
+@cli(bundle exec bin/na help plugin edit)
+```
+
+###### plugin run
+
+Run a plugin on selected actions (aliases: `x`). Supports input/output format flags and filters.
+
+```
+@cli(bundle exec bin/na help plugin run)
+```
+
+###### plugin enable
+
+Move a plugin from `plugins_disabled` to `plugins` (alias: `e`).
+
+```
+@cli(bundle exec bin/na help plugin enable)
+```
+
+###### plugin disable
+
+Move a plugin from `plugins` to `plugins_disabled` (alias: `d`).
+
+```
+@cli(bundle exec bin/na help plugin disable)
+```
+
 ##### projects
 
 List all projects in a file. If arguments are provided, they're used to match a todo file from history, otherwise the todo file(s) in the current directory will be used.
@@ -235,49 +326,6 @@ See the help output for a list of all available actions.
 @cli(bundle exec bin/na help update)
 ```
 
-#### Time tracking
-
-`na` supports tracking elapsed time between a start and finish for actions using `@started(YYYY-MM-DD HH:MM)` and `@done(YYYY-MM-DD HH:MM)` tags. Durations are not stored; they are calculated on the fly from these tags.
-
-- Add/Finish/Update flags:
-  - `--started TIME` set a start time when creating or finishing an item
-  - `--end TIME` (alias `--finished`) set a done time
-  - `--duration DURATION` backfill start time from the provided end time
-  - All flags accept natural language (via Chronic) and shorthand: `30m ago`, `-2h`, `2h30m`, `2:30 ago`, `yesterday 5pm`
-
-Examples:
-
-```bash
-na add --started "30 minutes ago" "Investigate bug"
-na complete --finished now --duration 2h30m "Investigate bug"
-na update --started "yesterday 3pm" --end "yesterday 5:15pm" "Investigate bug"
-```
-
-- Display flags (next/tagged):
-  - `--times` show per‑action durations and a grand total (implies `--done`)
-  - `--human` format durations as human‑readable text instead of `DD:HH:MM:SS`
-  - `--only_timed` show only actions that have both `@started` and `@done` (implies `--times --done`)
-  - `--only_times` output only the totals section (no action lines; implies `--times --done`)
-  - `--json_times` output a JSON object with timed items, per‑tag totals, and overall total (implies `--times --done`)
-
-Example outputs:
-
-```bash
-# Per‑action durations appended and totals table
-na next --times --human
-
-# Only totals table (Markdown), no action lines
-na tagged "tag*=bug" --only_times
-
-# JSON for scripting
-na next --json_times > times.json
-```
-
-Notes:
-
-- Any newly added or edited action text is scanned for natural‑language values in `@started(...)`/`@done(...)` and normalized to `YYYY‑MM‑DD HH:MM`.
-- The color of durations in output is configurable via the theme key `duration` (defaults to `{y}`).
-
 ##### changelog
 
 View recent changes with `na changelog` or `na changes`.
@@ -375,6 +423,49 @@ If you're using a single global file, you'll need `--cwd_as` to be `tag` or `pro
 
 After installing a hook, you'll need to close your terminal and start a new session to initialize the new commands.
 
+### Time tracking
+
+`na` supports tracking elapsed time between a start and finish for actions using `@started(YYYY-MM-DD HH:MM)` and `@done(YYYY-MM-DD HH:MM)` tags. Durations are not stored; they are calculated on the fly from these tags.
+
+- Add/Finish/Update flags:
+  - `--started TIME` set a start time when creating or finishing an item
+  - `--end TIME` (alias `--finished`) set a done time
+  - `--duration DURATION` backfill start time from the provided end time
+  - All flags accept natural language (via Chronic) and shorthand: `30m ago`, `-2h`, `2h30m`, `2:30 ago`, `yesterday 5pm`
+
+Examples:
+
+```bash
+na add --started "30 minutes ago" "Investigate bug"
+na complete --finished now --duration 2h30m "Investigate bug"
+na update --started "yesterday 3pm" --end "yesterday 5:15pm" "Investigate bug"
+```
+
+- Display flags (next/tagged):
+  - `--times` show per‑action durations and a grand total (implies `--done`)
+  - `--human` format durations as human‑readable text instead of `DD:HH:MM:SS`
+  - `--only_timed` show only actions that have both `@started` and `@done` (implies `--times --done`)
+  - `--only_times` output only the totals section (no action lines; implies `--times --done`)
+  - `--json_times` output a JSON object with timed items, per‑tag totals, and overall total (implies `--times --done`)
+
+Example outputs:
+
+```bash
+# Per‑action durations appended and totals table
+na next --times --human
+
+# Only totals table (Markdown), no action lines
+na tagged "tag*=bug" --only_times
+
+# JSON for scripting
+na next --json_times > times.json
+```
+
+Notes:
+
+- Any newly added or edited action text is scanned for natural‑language values in `@started(...)`/`@done(...)` and normalized to `YYYY‑MM‑DD HH:MM`.
+- The color of durations in output is configurable via the theme key `duration` (defaults to `{y}`).
+
 ### Plugins
 
 NA supports a plugin system that allows you to run external scripts to transform or process actions. Plugins are stored in `~/.local/share/na/plugins` and can be written in any language with a shebang.
@@ -389,19 +480,15 @@ You can delete or modify these sample plugins as needed.
 
 #### Running Plugins
 
-Run a plugin with:
-```bash
-na plugin PLUGIN_NAME
-```
+You can manage and run plugins using subcommands under `na plugin`:
 
-Or use plugins through the `update` command's interactive menu, or pipe actions through plugins on display commands:
+- `new`/`n`: scaffold a new plugin script
+- `edit`: open an existing plugin
+- `run`/`x`: run a plugin against selected actions
+- `enable`/`e`: move from disabled to enabled
+- `disable`/`d`: move from enabled to disabled
 
-```bash
-na update --plugin PLUGIN_NAME           # Run plugin on selected actions
-na next --plugin PLUGIN_NAME             # Transform output only (no file writes)
-na tagged bug --plugin PLUGIN_NAME       # Filter and transform
-na find "search term" --plugin PLUGIN_NAME
-```
+Plugins are executed with actions on STDIN and must return actions on STDOUT. Display commands can still pipe through plugins via `--plugin`, which only affects STDOUT (no writes).
 
 #### Plugin Metadata
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: na
 version: !ruby/object:Gem::Version
-  version: 1.2.88
+  version: 1.2.89
 platform: ruby
 authors:
 - Brett Terpstra
@@ -264,7 +264,6 @@ files:
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".travis.yml"
-- 2025-10-29-one-more-na-update.md
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock