howzit 2.1.16 → 2.1.21

data/lib/howzit/buildnote.rb

@@ -70,9 +70,39 @@ module Howzit
     def find_topic(term = nil)
       return @topics if term.nil?
 
+      rx = term.to_rx
+
+      @topics.filter do |topic|
+        title = topic.title.downcase.sub(/ *\(.*?\) *$/, '')
+        match = title =~ rx
+
+        if !match && term =~ /[,:]/
+          normalized = title.gsub(/\s*([,:])\s*/, '\1')
+          match = normalized =~ rx
+        end
+
+        match
+      end
+    end
+
+    ##
+    ## Find a topic with an exact whole-word match
+    ##
+    ## @param      term  [String] The search term
+    ##
+    ## @return     [Array] Array of topics that exactly match the term
+    ##
+    def find_topic_exact(term = nil)
+      return [] if term.nil?
+
       @topics.filter do |topic|
-        rx = term.to_rx
-        topic.title.downcase.sub(/ *\(.*?\) *$/, '') =~ rx
+        title = topic.title.downcase.sub(/ *\(.*?\) *$/, '').strip
+        # Split both the title and search term into words
+        title_words = title.split
+        search_words = term.split
+
+        # Check if all search words match the title words exactly (case-insensitive)
+        search_words.map(&:downcase) == title_words.map(&:downcase)
       end
     end
 
@@ -115,7 +145,11 @@ module Howzit
     ## @return     [Array] array of topic titles
     ##
     def list_topics
-      @topics.map(&:title)
+      @topics.map do |topic|
+        title = topic.title
+        title += "(#{topic.named_args.keys.join(', ')})" unless topic.named_args.empty?
+        title
+      end
     end
 
     ##
@@ -137,7 +171,11 @@ module Howzit
     def list_runnable_completions
       output = []
       @topics.each do |topic|
-        output.push(topic.title) if topic.tasks.count.positive?
+        next unless topic.tasks.count.positive?
+
+        title = topic.title
+        title += "(#{topic.named_args.keys.join(', ')})" unless topic.named_args.empty?
+        output.push(title)
       end
       output.join("\n")
     end
@@ -159,7 +197,10 @@ module Howzit
 
         next if s_out.empty?
 
-        output.push("- {bw}#{topic.title}{x}".c)
+        title = topic.title
+        title += " {dy}({xy}#{topic.named_args.keys.join(', ')}{dy}){x}" unless topic.named_args.empty?
+
+        output.push("- {g}#{title}{x}".c)
         output.push(s_out.join("\n"))
       end
 
@@ -328,6 +369,70 @@ module Howzit
 
     private
 
+    def topic_search_terms_from_cli
+      args = Howzit.cli_args || []
+      raw = args.join(' ').strip
+      return [] if raw.empty?
+
+      smart_split_topics(raw).map { |term| term.strip.downcase }.reject(&:empty?)
+    end
+
+    def smart_split_topics(raw)
+      segments, separators = segments_and_separators_for(raw)
+      return segments if separators.empty?
+
+      combined = []
+      current = segments.shift || ''
+
+      separators.each_with_index do |separator, idx|
+        next_segment = segments[idx] || ''
+        if keep_separator_with_current?(current, separator, next_segment)
+          current = "#{current}#{separator}#{next_segment}"
+        else
+          combined << current
+          current = next_segment
+        end
+      end
+
+      combined << current
+      combined
+    end
+
+    def segments_and_separators_for(raw)
+      segments = []
+      separators = []
+      current = String.new
+
+      raw.each_char do |char|
+        if char =~ /[,:]/
+          segments << current
+          separators << char
+          current = String.new
+        else
+          current << char
+        end
+      end
+
+      segments << current
+      [segments, separators]
+    end
+
+    def keep_separator_with_current?(current, separator, next_segment)
+      candidate = "#{current}#{separator}#{next_segment}"
+      normalized_candidate = normalize_separator_string(candidate)
+      return false if normalized_candidate.empty?
+
+      @topics.any? do |topic|
+        normalize_separator_string(topic.title).start_with?(normalized_candidate)
+      end
+    end
+
+    def normalize_separator_string(string)
+      return '' if string.nil?
+
+      string.downcase.gsub(/\s+/, ' ').strip.gsub(/\s*([,:])\s*/, '\1')
+    end
+
     ##
     ## Import the contents of a filename as new topics
     ##
@@ -718,6 +823,10 @@ module Howzit
     ##
     def process
       output = []
+      if Howzit.options[:run]
+        Howzit.run_log = []
+        Howzit.multi_topic_run = false
+      end
 
       unless note_file
         Process.exit 0 if Howzit.options[:list_runnable_titles] || Howzit.options[:list_topic_titles]
@@ -757,62 +866,139 @@ module Howzit
         Process.exit(0)
       end
 
-      topic_matches = []
-
+      # Handle grep and choose modes (batch all results)
       if Howzit.options[:grep]
+        topic_matches = []
         matches = grep(Howzit.options[:grep])
         case Howzit.options[:multiple_matches]
         when :all
           topic_matches.concat(matches.sort_by(&:title))
         else
-          topic_matches.concat(Prompt.choose(matches.map(&:title), height: :max))
+          topic_matches.concat(Prompt.choose(matches.map(&:title), height: :max, query: Howzit.options[:grep]))
         end
+        process_topic_matches(topic_matches, output)
       elsif Howzit.options[:choose]
+        topic_matches = []
         titles = Prompt.choose(list_topics, height: :max)
         titles.each { |title| topic_matches.push(find_topic(title)[0]) }
-      # If there are arguments use those to search for a matching topic
+        process_topic_matches(topic_matches, output)
       elsif !Howzit.cli_args.empty?
-        search = Howzit.cli_args.join(' ').strip.downcase.split(/ *, */).map(&:strip)
+        # Collect all topic matches first (showing menus as needed)
+        search = topic_search_terms_from_cli
+        topic_matches = collect_topic_matches(search, output)
+        process_topic_matches(topic_matches, output)
+      else
+        # No arguments - show all topics
+        if Howzit.options[:run]
+          Howzit.run_log = []
+          Howzit.multi_topic_run = topics.length > 1
+        end
+        topics.each { |k| output.push(process_topic(k, false, single: false)) }
+        finalize_output(output)
+      end
+    end
+
+    ##
+    ## Collect all topic matches from search terms, showing menus as needed
+    ## but not displaying/running until all selections are made
+    ##
+    ## @param      search_terms  [Array] Array of search term strings
+    ## @param      output        [Array] Output array for error messages
+    ##
+    ## @return     [Array] Array of all matched topics
+    ##
+    def collect_topic_matches(search_terms, output)
+      all_matches = []
 
-        search.each do |s|
-          matches = find_topic(s)
+      search_terms.each do |s|
+        # First check for exact whole-word matches
+        exact_matches = find_topic_exact(s)
 
-          if matches.empty?
-            output.push(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n).c)
-          else
-            case Howzit.options[:multiple_matches]
-            when :first
-              topic_matches.push(matches[0])
-            when :best
-              topic_matches.push(matches.sort_by { |a| [a.title.comp_distance(s), a.title.length] })
-            when :all
-              topic_matches.concat(matches)
-            else
-              titles = matches.map(&:title)
-              res = Prompt.choose(titles)
-              old_matching = Howzit.options[:matching]
-              Howzit.options[:matching] = 'exact'
-              res.each { |title| topic_matches.concat(find_topic(title)) }
-              Howzit.options[:matching] = old_matching
-            end
-          end
-        end
+        topic_matches = if !exact_matches.empty?
+                          exact_matches
+                        else
+                          resolve_fuzzy_matches(s, output)
+                        end
 
-        if topic_matches.empty? && !Howzit.options[:show_all_on_error]
-          Util.show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
-          Process.exit 1
+        if topic_matches.empty?
+          output.push(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n).c)
+        else
+          all_matches.concat(topic_matches)
         end
       end
 
+      all_matches
+    end
+
+    ##
+    ## Resolve fuzzy matches for a search term
+    ##
+    ## @param      search_term  [String] The search term
+    ## @param      output       [Array] Output array for errors
+    ##
+    ## @return     [Array] Array of matched topics
+    ##
+    def resolve_fuzzy_matches(search_term, output)
+      matches = find_topic(search_term)
+
+      return [] if matches.empty?
+
+      case Howzit.options[:multiple_matches]
+      when :first
+        [matches[0]]
+      when :best
+        [matches.sort_by { |a| [a.title.comp_distance(search_term), a.title.length] }.first]
+      when :all
+        matches
+      else
+        titles = matches.map(&:title)
+        res = Prompt.choose(titles, query: search_term)
+        old_matching = Howzit.options[:matching]
+        Howzit.options[:matching] = 'exact'
+        selected = res.flat_map { |title| find_topic(title) }
+        Howzit.options[:matching] = old_matching
+        selected
+      end
+    end
+
+    ##
+    ## Process collected topic matches and display output
+    ##
+    ## @param      topic_matches  [Array] Array of matched topics
+    ## @param      output         [Array] Output array
+    ##
+    def process_topic_matches(topic_matches, output)
+      if topic_matches.empty? && !Howzit.options[:show_all_on_error]
+        Util.show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
+        Process.exit 1
+      end
+
+      if Howzit.options[:run]
+        Howzit.run_log = []
+        Howzit.multi_topic_run = topic_matches.length > 1
+      end
+
       if !topic_matches.empty?
-        # If we found a match
         topic_matches.map! { |topic| topic.is_a?(String) ? find_topic(topic)[0] : topic }
         topic_matches.each { |topic_match| output.push(process_topic(topic_match, Howzit.options[:run], single: true)) }
       else
-        # If there's no argument or no match found, output all
         topics.each { |k| output.push(process_topic(k, false, single: false)) }
       end
-      Howzit.options[:paginate] = false if Howzit.options[:run]
+
+      finalize_output(output)
+    end
+
+    ##
+    ## Finalize and display output with run summary if applicable
+    ##
+    ## @param      output  [Array] Output array
+    ##
+    def finalize_output(output)
+      if Howzit.options[:run]
+        Howzit.options[:paginate] = false
+        summary = Howzit::RunReport.format
+        output.push(summary) unless summary.empty?
+      end
       Util.show(output.join("\n").strip, Howzit.options)
     end
   end

data/lib/howzit/prompt.rb

@@ -83,21 +83,24 @@ 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)
+        tty_menu(matches, query: query)
       end
 
       def fzf_result(res)
@@ -108,7 +111,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 +124,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 +133,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 +145,9 @@ module Howzit
           exit
         end
 
+        if query
+          puts "\nSelect a topic for `#{query}`:"
+        end
         options_list(matches)
         read_selection(matches)
       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.16'
+  VERSION = '2.1.21'
 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