howzit 2.1.18 → 2.1.22

data/lib/howzit/prompt.rb

@@ -83,21 +83,28 @@ module Howzit
       ##                      number of options, anything
       ##                      else gets max height for
       ##                      terminal)
+      ## @param      query    [String] The search term to display in prompt
       ##
       ## @return     [Array] the selected results
       ##
-      def choose(matches, height: :auto)
-        return [] if !$stdout.isatty || matches.count.zero?
+      def choose(matches, height: :auto, query: nil)
+        return [] if matches.count.zero?
+        return matches if matches.count == 1
+        return [] unless $stdout.isatty
 
         if Util.command_exist?('fzf')
           height = height == :auto ? matches.count + 3 : TTY::Screen.rows
 
-          settings = fzf_options(height)
+          settings = fzf_options(height, query: query)
           res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
           return fzf_result(res)
         end
 
-        tty_menu(matches)
+        if Util.command_exist?('gum')
+          return gum_choose(matches, query: query, multi: true)
+        end
+
+        tty_menu(matches, query: query)
       end
 
       def fzf_result(res)
@@ -108,7 +115,12 @@ module Howzit
         res.split(/\n/)
       end
 
-      def fzf_options(height)
+      def fzf_options(height, query: nil)
+        prompt = if query
+                   "Select a topic for \\`#{query}\\` > "
+                 else
+                   'Select a topic > '
+                 end
         [
           '-0',
           '-1',
@@ -116,7 +128,7 @@ module Howzit
           "--height=#{height}",
           '--header="Tab: add selection, ctrl-a/d: (de)select all, return: display/run"',
           '--bind ctrl-a:select-all,ctrl-d:deselect-all,ctrl-t:toggle-all',
-          '--prompt="Select a topic > "',
+          "--prompt=\"#{prompt}\"",
           %(--preview="howzit --no-pager --header-format block --no-color --default --multiple first {}")
         ]
       end
@@ -125,8 +137,9 @@ module Howzit
       ## Display a numeric menu on the TTY
       ##
       ## @param      matches  The matches from which to select
+      ## @param      query    [String] The search term to display
       ##
-      def tty_menu(matches)
+      def tty_menu(matches, query: nil)
         return matches if matches.count == 1
 
         @stty_save = `stty -g`.chomp
@@ -136,6 +149,9 @@ module Howzit
           exit
         end
 
+        if query
+          puts "\nSelect a topic for `#{query}`:"
+        end
         options_list(matches)
         read_selection(matches)
       end
@@ -187,6 +203,190 @@ module Howzit
         end
         line == '' ? 1 : line.to_i
       end
+
+      ##
+      ## Multi-select menu for templates
+      ##
+      ## @param      matches  [Array] The options list
+      ## @param      prompt_text  [String] The prompt to display
+      ##
+      ## @return     [Array] the selected results (can be empty)
+      ##
+      def choose_templates(matches, prompt_text: 'Select templates')
+        return [] if matches.count.zero?
+        return [] unless $stdout.isatty
+
+        if Util.command_exist?('fzf')
+          height = matches.count + 3
+          settings = fzf_template_options(height, prompt_text: prompt_text)
+
+          # Save terminal state before fzf
+          tty_state = `stty -g`.chomp
+          res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
+          # Restore terminal state after fzf
+          system("stty #{tty_state}")
+
+          return res.empty? ? [] : res.split(/\n/)
+        end
+
+        if Util.command_exist?('gum')
+          return gum_choose(matches, prompt: prompt_text, multi: true, required: false)
+        end
+
+        text_template_input(matches)
+      end
+
+      ##
+      ## FZF options for template selection
+      ##
+      def fzf_template_options(height, prompt_text: 'Select templates')
+        [
+          '-0',
+          '-m',
+          "--height=#{height}",
+          '--header="Tab: add selection, ctrl-a/d: (de)select all, esc: skip, return: confirm"',
+          '--bind ctrl-a:select-all,ctrl-d:deselect-all,ctrl-t:toggle-all',
+          "--prompt=\"#{prompt_text} > \""
+        ]
+      end
+
+      ##
+      ## Text-based template input with fuzzy matching
+      ##
+      ## @param      available  [Array] Available template names
+      ##
+      ## @return     [Array] Matched template names
+      ##
+      def text_template_input(available)
+        @stty_save = `stty -g`.chomp
+
+        trap('INT') do
+          system('stty', @stty_save)
+          exit
+        end
+
+        puts "\n{bw}Available templates:{x} #{available.join(', ')}".c
+        printf '{bw}Enter templates to include, comma-separated (return to skip):{x} '.c
+        input = Readline.readline('', true).strip
+
+        return [] if input.empty?
+
+        fuzzy_match_templates(input, available)
+      ensure
+        system('stty', @stty_save) if @stty_save
+      end
+
+      ##
+      ## Fuzzy match user input against available templates
+      ##
+      ## @param      input      [String] Comma-separated user input
+      ## @param      available  [Array] Available template names
+      ##
+      ## @return     [Array] Matched template names
+      ##
+      def fuzzy_match_templates(input, available)
+        terms = input.split(',').map(&:strip).reject(&:empty?)
+        matched = []
+
+        terms.each do |term|
+          # Try exact match first (case-insensitive)
+          exact = available.find { |t| t.downcase == term.downcase }
+          if exact
+            matched << exact unless matched.include?(exact)
+            next
+          end
+
+          # Try fuzzy match using the same regex approach as topic matching
+          rx = term.to_rx
+          fuzzy = available.select { |t| t =~ rx }
+
+          # Prefer matches that start with the term
+          if fuzzy.length > 1
+            starts_with = fuzzy.select { |t| t.downcase.start_with?(term.downcase) }
+            fuzzy = starts_with unless starts_with.empty?
+          end
+
+          fuzzy.each { |t| matched << t unless matched.include?(t) }
+        end
+
+        matched
+      end
+
+      ##
+      ## Prompt for a single line of input
+      ##
+      ## @param      prompt_text  [String] The prompt to display
+      ## @param      default      [String] Default value if empty
+      ##
+      ## @return     [String] the entered value
+      ##
+      def get_line(prompt_text, default: nil)
+        return (default || '') unless $stdout.isatty
+
+        if Util.command_exist?('gum')
+          result = gum_input(prompt_text, placeholder: default || '')
+          return result.empty? && default ? default : result
+        end
+
+        prompt_with_default = default ? "#{prompt_text} [#{default}]: " : "#{prompt_text}: "
+        result = Readline.readline(prompt_with_default, true).to_s.strip
+        result.empty? && default ? default : result
+      end
+
+      ##
+      ## Use gum for single or multi-select menu
+      ##
+      ## @param      matches   [Array] The options list
+      ## @param      prompt    [String] The prompt text
+      ## @param      multi     [Boolean] Allow multiple selections
+      ## @param      required  [Boolean] Require at least one selection
+      ## @param      query     [String] The search term for display
+      ##
+      ## @return     [Array] Selected items
+      ##
+      def gum_choose(matches, prompt: nil, multi: false, required: true, query: nil)
+        prompt_text = prompt || (query ? "Select for '#{query}'" : 'Select')
+        args = ['gum', 'choose']
+        args << '--no-limit' if multi
+        args << "--header=#{Shellwords.escape(prompt_text)}"
+        args << '--cursor.foreground=6'
+        args << '--selected.foreground=2'
+
+        tty_state = `stty -g`.chomp
+        res = `echo #{Shellwords.escape(matches.join("\n"))} | #{args.join(' ')}`.strip
+        system("stty #{tty_state}")
+
+        if res.empty?
+          if required
+            Howzit.console.info 'Cancelled'
+            Process.exit 0
+          end
+          return []
+        end
+
+        res.split(/\n/)
+      end
+
+      ##
+      ## Use gum for text input
+      ##
+      ## @param      prompt_text   [String] The prompt to display
+      ## @param      placeholder   [String] Placeholder text
+      ##
+      ## @return     [String] The entered value
+      ##
+      def gum_input(prompt_text, placeholder: '')
+        args = ['gum', 'input']
+        args << "--header=#{Shellwords.escape(prompt_text)}"
+        args << "--placeholder=#{Shellwords.escape(placeholder)}" unless placeholder.empty?
+        args << '--cursor.foreground=6'
+
+        tty_state = `stty -g`.chomp
+        res = `#{args.join(' ')}`.strip
+        system("stty #{tty_state}")
+
+        res
+      end
     end
   end
 end

data/lib/howzit/run_report.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Howzit
+  # Formatter for task run summaries
+  module RunReport
+    module_function
+
+    def reset
+      Howzit.run_log = []
+    end
+
+    def log(entry)
+      Howzit.run_log = [] if Howzit.run_log.nil?
+      Howzit.run_log << entry
+    end
+
+    def entries
+      Howzit.run_log || []
+    end
+
+    def format
+      return '' if entries.empty?
+
+      lines = entries.map { |entry| format_line(entry, Howzit.multi_topic_run) }
+      lines.map! { |line| line.rstrip }
+      widths = lines.map { |line| line.uncolor.length }
+      width = widths.max
+      top = '=' * width
+      bottom = '-' * width
+      output_lines = [top] + lines + [bottom]
+      result = output_lines.join("\n")
+      result = result.gsub(/\n[ \t]+\n/, "\n")
+      result.gsub(/\n{2,}/, "\n")
+    end
+
+    def format_line(entry, prefix_topic)
+      bullet_start = '{mb}- [{x}'
+      bullet_end = '{mb}] {x}'
+      symbol = entry[:success] ? '{bg}✓{x}' : '{br}X{x}'
+      parts = []
+      parts << "#{bullet_start}#{symbol}#{bullet_end}"
+      parts << "{bl}#{entry[:topic]}{x}: " if prefix_topic && entry[:topic] && !entry[:topic].empty?
+      parts << "{by}#{entry[:task]}{x}"
+      unless entry[:success]
+        reason = entry[:exit_status] ? "exit code #{entry[:exit_status]}" : 'failed'
+        parts << " {br}(Failed: #{reason}){x}"
+      end
+      parts.join.c
+    end
+  end
+end

data/lib/howzit/stringutils.rb

@@ -183,7 +183,9 @@ module Howzit
 
     # Just strip out color codes when requested
     def uncolor
-      gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/, '')
+      # force UTF-8 and remove invalid characters, then remove color codes
+      # and iTerm markers
+      gsub(Howzit::Color::COLORED_REGEXP, "").gsub(/\e\]1337;SetMark/, "")
     end
 
     # Wrap text at a specified width.

data/lib/howzit/task.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'English'
+
 module Howzit
   # Task object
   class Task
-    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default
+    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status
 
     ##
     ## Initialize a Task object
@@ -31,6 +33,7 @@ module Howzit
 
       @optional = optional
       @default = default
+      @last_status = nil
     end
 
     ##
@@ -68,6 +71,7 @@ module Howzit
         script.unlink
       end
 
+      update_last_status(res ? 0 : 1)
       res
     end
 
@@ -86,6 +90,7 @@ module Howzit
       Howzit.console.info("#{@prefix}{by}Running tasks from {bw}#{matches[0].title}{x}".c)
       output.concat(matches[0].run(nested: true))
       Howzit.console.info("{by}End include: #{matches[0].tasks.count} tasks{x}".c)
+      @last_status = nil
       [output, matches[0].tasks.count]
     end
 
@@ -96,7 +101,9 @@ module Howzit
       title = Howzit.options[:show_all_code] ? @action : @title
       Howzit.console.info("#{@prefix}{bg}Running {bw}#{title}{x}".c)
       ENV['HOWZIT_SCRIPTS'] = File.expand_path('~/.config/howzit/scripts')
-      system(@action)
+      res = system(@action)
+      update_last_status(res ? 0 : 1)
+      res
     end
 
     ##
@@ -106,6 +113,7 @@ module Howzit
       title = Howzit.options[:show_all_code] ? @action : @title
       Howzit.console.info("#{@prefix}{bg}Copied {bw}#{title}{bg} to clipboard{x}".c)
       Util.os_copy(@action)
+      @last_status = 0
       true
     end
 
@@ -127,12 +135,23 @@ module Howzit
                 run_copy
               when :open
                 Util.os_open(@action)
+                @last_status = 0
+                true
               end
             end
 
       [output, tasks, res]
     end
 
+    def update_last_status(default = nil)
+      status = if defined?($CHILD_STATUS) && $CHILD_STATUS
+                 $CHILD_STATUS.exitstatus
+               else
+                 default
+               end
+      @last_status = status
+    end
+
     ##
     ## Output terminal-formatted list item
     ##

data/lib/howzit/topic.rb

@@ -104,6 +104,8 @@ module Howzit
 
             break unless Howzit.options[:force]
           end
+
+          log_task_result(task, success)
         end
 
         total = "{bw}#{@results[:total]}{by} #{@results[:total] == 1 ? 'task' : 'tasks'}".c
@@ -119,7 +121,7 @@ module Howzit
         Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
       end
 
-      output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested
+      output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
 
       puts TTY::Box.frame("{bw}#{@postreqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols) unless @postreqs.empty?
 
@@ -324,6 +326,27 @@ module Howzit
     ##
     ## @return     [Array] array of Task objects
     ##
+    def log_task_result(task, success)
+      return unless Howzit.options[:run]
+      return if task.type == :include
+
+      Howzit.run_log ||= []
+
+      title = (task.title || '').strip
+      if title.empty?
+        action = (task.action || '').strip
+        title = action.split(/\n/).first.to_s.strip
+      end
+      title = task.type.to_s.capitalize if title.nil? || title.empty?
+
+      Howzit.run_log << {
+        topic: @title,
+        task: title,
+        success: success ? true : false,
+        exit_status: task.last_status
+      }
+    end
+
     def gather_tasks
       runnable = []
       @prereqs = @content.scan(/(?<=@before\n).*?(?=\n@end)/im).map(&:strip)

data/lib/howzit/util.rb

@@ -145,7 +145,11 @@ module Howzit
         end
 
         read_io.close
-        write_io.write(text)
+        begin
+          write_io.write(text)
+        rescue Errno::EPIPE
+          # User quit pager before we finished writing, ignore
+        end
         write_io.close
 
         _, status = Process.waitpid2(pid)

data/lib/howzit/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.1.18'
+  VERSION = '2.1.22'
 end

data/lib/howzit.rb

@@ -41,6 +41,7 @@ require_relative 'howzit/config'
 require_relative 'howzit/task'
 require_relative 'howzit/topic'
 require_relative 'howzit/buildnote'
+require_relative 'howzit/run_report'
 
 require 'tty/screen'
 require 'tty/box'
@@ -49,7 +50,7 @@ require 'tty/box'
 # Main module for howzit
 module Howzit
   class << self
-    attr_accessor :arguments, :named_arguments, :cli_args
+    attr_accessor :arguments, :named_arguments, :cli_args, :run_log, :multi_topic_run
 
     ##
     ## Holds a Configuration object with methods and a @settings hash
@@ -88,10 +89,18 @@ module Howzit
       @console ||= Howzit::ConsoleLogger.new(options[:log_level])
     end
 
+    def run_log
+      @run_log ||= []
+    end
+
+    def multi_topic_run
+      @multi_topic_run ||= false
+    end
+
     def has_read_upstream
       @has_read_upstream ||= false
     end
 
-    attr_writer :has_read_upstream
+    attr_writer :has_read_upstream, :run_log
   end
 end

data/spec/buildnote_spec.rb

@@ -62,6 +62,12 @@ describe Howzit::BuildNote do
       expect(matches.count).to eq 0
     end
 
+    it "matches topics containing colon even without space" do
+      matches = how.find_topic('git:clean')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Git: Clean Repo'
+    end
+
     it "Handles multiple matches with best match" do
       Howzit.options[:matching] = 'fuzzy'
       Howzit.options[:multiple_matches] = :best
@@ -70,12 +76,164 @@ describe Howzit::BuildNote do
     end
   end
 
+  describe ".find_topic_exact" do
+    it "finds exact whole-word match" do
+      matches = how.find_topic_exact('Topic Tropic')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+
+    it "finds exact match case-insensitively" do
+      matches = how.find_topic_exact('topic tropic')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+
+    it "does not match partial phrases" do
+      matches = how.find_topic_exact('topic trop')
+      expect(matches.count).to eq 0
+    end
+
+    it "does not match single word when phrase has multiple words" do
+      matches = how.find_topic_exact('topic')
+      expect(matches.count).to eq 0
+    end
+
+    it "matches single-word topics" do
+      matches = how.find_topic_exact('Happy Bgagngagnga')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Happy Bgagngagnga'
+    end
+
+    it "matches topics with colons" do
+      matches = how.find_topic_exact('Git: Clean Repo')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Git: Clean Repo'
+    end
+  end
+
   describe ".topics" do
-    it "contains 4 topics" do
-      expect(how.list_topics.count).to eq 4
+    it "contains 7 topics" do
+      expect(how.list_topics.count).to eq 7
     end
     it "outputs a newline-separated string for completion" do
-      expect(how.list_completions.scan(/\n/).count).to eq 3
+      expect(how.list_completions.scan(/\n/).count).to eq 6
+    end
+  end
+
+  describe "#topic_search_terms_from_cli" do
+    after { Howzit.cli_args = [] }
+
+    it "respects separators found inside topics" do
+      Howzit.cli_args = ['git:clean:blog:update post']
+      expect(how.send(:topic_search_terms_from_cli)).to eq(['git:clean', 'blog:update post'])
+    end
+
+    it "keeps comma inside matching topics" do
+      Howzit.cli_args = ['release, deploy,topic balogna']
+      expect(how.send(:topic_search_terms_from_cli)).to eq(['release, deploy', 'topic balogna'])
+    end
+  end
+
+  describe "#collect_topic_matches" do
+    before do
+      Howzit.options[:multiple_matches] = :first
+    end
+
+    it "collects matches for multiple search terms" do
+      search_terms = ['topic tropic', 'topic banana']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 2
+      expect(matches.map(&:title)).to include('Topic Tropic', 'Topic Banana')
+    end
+
+    it "prefers exact matches over fuzzy matches" do
+      # 'Topic Banana' should exact-match, not fuzzy match to multiple
+      search_terms = ['topic banana']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Banana'
+    end
+
+    it "falls back to fuzzy match when no exact match" do
+      Howzit.options[:matching] = 'fuzzy'
+      search_terms = ['trpc']  # fuzzy for 'tropic'
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+
+    it "adds error message for unmatched terms" do
+      search_terms = ['nonexistent topic xyz']
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 0
+      expect(output.join).to match(/no topic match found/i)
+    end
+
+    it "collects multiple topics from comma-separated input" do
+      Howzit.cli_args = ['topic tropic,topic banana']
+      search_terms = how.send(:topic_search_terms_from_cli)
+      output = []
+      matches = how.send(:collect_topic_matches, search_terms, output)
+      expect(matches.count).to eq 2
+      Howzit.cli_args = []
+    end
+  end
+
+  describe "#smart_split_topics" do
+    it "splits on comma when not part of topic title" do
+      result = how.send(:smart_split_topics, 'topic tropic,topic banana')
+      expect(result).to eq(['topic tropic', 'topic banana'])
+    end
+
+    it "preserves comma when part of topic title" do
+      result = how.send(:smart_split_topics, 'release, deploy,topic banana')
+      expect(result).to eq(['release, deploy', 'topic banana'])
+    end
+
+    it "preserves colon when part of topic title" do
+      result = how.send(:smart_split_topics, 'git:clean,blog:update post')
+      expect(result).to eq(['git:clean', 'blog:update post'])
+    end
+
+    it "handles mixed separators correctly" do
+      result = how.send(:smart_split_topics, 'git:clean:topic tropic')
+      expect(result).to eq(['git:clean', 'topic tropic'])
+    end
+  end
+
+  describe "#parse_template_required_vars" do
+    let(:template_with_required) do
+      Tempfile.new(['template', '.md']).tap do |f|
+        f.write("required: repo_url, author\n\n# Template\n\n## Section")
+        f.close
+      end
+    end
+
+    let(:template_without_required) do
+      Tempfile.new(['template', '.md']).tap do |f|
+        f.write("# Template\n\n## Section")
+        f.close
+      end
+    end
+
+    after do
+      template_with_required.unlink
+      template_without_required.unlink
+    end
+
+    it "parses required variables from template metadata" do
+      vars = how.send(:parse_template_required_vars, template_with_required.path)
+      expect(vars).to eq(['repo_url', 'author'])
+    end
+
+    it "returns empty array when no required metadata" do
+      vars = how.send(:parse_template_required_vars, template_without_required.path)
+      expect(vars).to eq([])
     end
   end
 end