howzit 2.1.21 → 2.1.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6cac91a8b188ff256fa863ad94e134e820ed2aa2eb766a10fea38ee745de750
-  data.tar.gz: 90799282be7a348b595df19a5c09850db8ac4d653bd81063d49f1830e6cb0761
+  metadata.gz: 6fc52d90b2a71d349a14e77f6e313baed51003a43ce2ca615a31f0b070f0681e
+  data.tar.gz: fa0fa63742822ef396b45abc56b6ae7dfbc7acb72a4c896a9e6570cc9e13b1c3
 SHA512:
-  metadata.gz: 6b98ee5eb923878803f0268080ad1d56f4f9aed7279e6dcb245f13659e3a947348212741b3409861aacff145bc5abb19af7dd9810a854626e6b5067fc33ad954
-  data.tar.gz: 9be180170d36f0f415e3f0977b5b951368f7498fe630cd4f900626bf852c5678b860cea8ac63472dec0c03c41531cf70eb58a5002298a5ed9f5661204aa6d7cb
+  metadata.gz: d7e01306310519e4454960b5246740572a7731aa4946fa3d4d455ee3f9a3c30b1415eabdf91a58dca48d0123a0b78332754d7e4d86bd112692574b517a328072
+  data.tar.gz: 99ab41b0612da8c5a0e456c5a5006e9dc6cf5e679726b461cba170622d3aa615fe6a259c50dec67b2b4c7151afff200af8d8cf2c3dfe1d775b0dea83e3975fba

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+### 2.1.23
+
+2025-12-13 06:38
+
+#### CHANGED
+
+- Output format changed from bordered text to markdown table
+
+#### NEW
+
+- Added emoji header () to run report table
+
+#### IMPROVED
+
+- Status indicators now use emoji (/) instead of text symbols
+- Failure messages now show "(exit code X)" instead of "Failed: exit code X"
+
+### 2.1.22
+
+2025-12-13 06:14
+
+#### NEW
+
+- Template selection menu when creating new build notes
+- Prompt for required template variables during note creation
+- Gum support as fallback for menus and text input
+
+#### IMPROVED
+
+- Fuzzy matching for template names when fzf unavailable
+- Text input uses Readline for proper line editing (backspace, ctrl-a/e)
+
 ### 2.1.21
 
 2025-12-13 05:03

data/lib/howzit/buildnote.rb

@@ -293,27 +293,37 @@ module Howzit
       if default
         input = title
       else
-        # title = prompt.ask("{bw}Project name:{x}".c, default: title)
-        printf "{bw}Project name {xg}[#{title}]{bw}: {x}".c
-        input = $stdin.gets.chomp
-        title = input unless input.empty?
+        title = Prompt.get_line('{bw}Project name{x}'.c, default: title)
       end
       summary = ''
       unless default
-        printf '{bw}Project summary: {x}'.c
-        input = $stdin.gets.chomp
-        summary = input unless input.empty?
+        summary = Prompt.get_line('{bw}Project summary{x}'.c)
+      end
+
+      # Template selection
+      selected_templates = []
+      template_metadata = {}
+      unless default
+        selected_templates, template_metadata = select_templates_for_note(title)
       end
 
       fname = 'buildnotes.md'
       unless default
-        printf "{bw}Build notes filename (must begin with 'howzit' or 'build')\n{xg}[#{fname}]{bw}: {x}".c
-        input = $stdin.gets.chomp
-        fname = input unless input.empty?
+        fname = Prompt.get_line("{bw}Build notes filename{x}\n(must begin with 'howzit' or 'build')".c, default: fname)
+      end
+
+      # Build metadata section
+      metadata_lines = []
+      unless selected_templates.empty?
+        metadata_lines << "template: #{selected_templates.join(',')}"
+      end
+      template_metadata.each do |key, value|
+        metadata_lines << "#{key}: #{value}"
       end
+      metadata_section = metadata_lines.empty? ? '' : "#{metadata_lines.join("\n")}\n\n"
 
       note = <<~EOBUILDNOTES
-        # #{title}
+        #{metadata_section}# #{title}
 
         #{summary}
 
@@ -369,6 +379,68 @@ module Howzit
 
     private
 
+    ##
+    ## Select templates for a new build note
+    ##
+    ## @param      project_title  [String] The project title for prompts
+    ##
+    ## @return     [Array<Array, Hash>] Array of [selected_template_names, required_vars_hash]
+    ##
+    def select_templates_for_note(project_title)
+      template_dir = Howzit.config.template_folder
+      template_glob = File.join(template_dir, '*.md')
+      template_files = Dir.glob(template_glob)
+
+      return [[], {}] if template_files.empty?
+
+      # Get basenames without extension for menu
+      template_names = template_files.map { |f| File.basename(f, '.md') }.sort
+
+      # Show multi-select menu
+      selected = Prompt.choose_templates(template_names, prompt_text: 'Select templates to include')
+      return [[], {}] if selected.empty?
+
+      # Prompt for required variables from each template
+      required_vars = {}
+      selected.each do |template_name|
+        template_path = File.join(template_dir, "#{template_name}.md")
+        next unless File.exist?(template_path)
+
+        vars = parse_template_required_vars(template_path)
+        vars.each do |var|
+          next if required_vars.key?(var)
+
+          value = Prompt.get_line("{bw}[#{template_name}] requires {by}#{var}{x}".c)
+          required_vars[var] = value unless value.empty?
+        end
+      end
+
+      [selected, required_vars]
+    end
+
+    ##
+    ## Parse a template file for required variables
+    ##
+    ## @param      template_path  [String] Path to the template file
+    ##
+    ## @return     [Array] Array of required variable names
+    ##
+    def parse_template_required_vars(template_path)
+      content = File.read(template_path)
+
+      # Look for required: in the metadata at the top of the file
+      # Metadata is before the first # heading
+      meta_section = content.split(/^#/)[0]
+      return [] if meta_section.nil? || meta_section.strip.empty?
+
+      # Find the required: line
+      match = meta_section.match(/^required:\s*(.+)$/i)
+      return [] unless match
+
+      # Split by comma and strip whitespace
+      match[1].split(',').map(&:strip).reject(&:empty?)
+    end
+
     def topic_search_terms_from_cli
       args = Howzit.cli_args || []
       raw = args.join(' ').strip

data/lib/howzit/prompt.rb

@@ -100,6 +100,10 @@ module Howzit
           return fzf_result(res)
         end
 
+        if Util.command_exist?('gum')
+          return gum_choose(matches, query: query, multi: true)
+        end
+
         tty_menu(matches, query: query)
       end
 
@@ -199,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

@@ -21,31 +21,58 @@ module Howzit
     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")
+      rows = entries.map { |entry| format_row(entry, Howzit.multi_topic_run) }
+
+      # Status column: emoji + 1 space on each side = 3 chars wide visually
+      # But emojis are 2-width in terminal, so we need width of 4 for " ✅ "
+      status_width = 4
+      task_width = [4, rows.map { |r| r[:task_plain].length }.max].max
+
+      # Build the table with emoji header
+      header = "| 🚥 | #{'Task'.ljust(task_width)} |"
+      separator = "| #{':' + '-' * 2 + ':'} | #{':' + '-' * (task_width - 2)} |"
+
+      table_lines = [header, separator]
+      rows.each do |row|
+        table_lines << table_row_colored(row[:status], row[:task], row[:task_plain], status_width, task_width)
+      end
+
+      table_lines.join("\n")
+    end
+
+    def table_row_colored(status, task, task_plain, status_width, task_width)
+      task_padding = task_width - task_plain.length
+
+      "| #{status} | #{task}#{' ' * task_padding} |"
     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}"
+    def format_row(entry, prefix_topic)
+      symbol = entry[:success] ? '✅' : '❌'
+      symbol_colored = entry[:success] ? '{bg}✅{x}'.c : '{br}❌{x}'.c
+
+      task_parts = []
+      task_parts_plain = []
+
+      if prefix_topic && entry[:topic] && !entry[:topic].empty?
+        task_parts << "{bw}#{entry[:topic]}{x}: "
+        task_parts_plain << "#{entry[:topic]}: "
+      end
+
+      task_parts << "{by}#{entry[:task]}{x}"
+      task_parts_plain << entry[:task]
+
       unless entry[:success]
         reason = entry[:exit_status] ? "exit code #{entry[:exit_status]}" : 'failed'
-        parts << " {br}(Failed: #{reason}){x}"
+        task_parts << " {br}(#{reason}){x}"
+        task_parts_plain << " (#{reason})"
       end
-      parts.join.c
+
+      {
+        status: symbol_colored,
+        status_plain: symbol,
+        task: task_parts.join.c,
+        task_plain: task_parts_plain.join
+      }
     end
   end
 end

data/lib/howzit/version.rb

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

data/spec/buildnote_spec.rb

@@ -134,4 +134,106 @@ describe Howzit::BuildNote do
       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

data/spec/run_report_spec.rb

@@ -13,14 +13,14 @@ describe Howzit::RunReport do
     Howzit.multi_topic_run = false
   end
 
-  it 'renders a bordered summary for single topic runs' do
+  it 'renders a markdown table for single topic runs' do
     Howzit::RunReport.log({ topic: 'Git: Config', task: 'Run Git Origin', success: true, exit_status: 0 })
     plain = Howzit::RunReport.format.uncolor
-    expect(plain).to include('- [✓] Run Git Origin')
+    expect(plain).to include('| 🚥 |')
+    expect(plain).to include('| Task')
+    expect(plain).to include('✅')
+    expect(plain).to include('Run Git Origin')
     expect(plain).not_to include('Git: Config:')
-    top, line, bottom = plain.split("\n")
-    expect(top).to eq('=' * line.length)
-    expect(bottom).to eq('-' * line.length)
   end
 
   it 'prefixes topic titles and shows failures when multiple topics run' do
@@ -28,8 +28,25 @@ describe Howzit::RunReport do
     Howzit::RunReport.log({ topic: 'Git: Config', task: 'Run Git Origin', success: true, exit_status: 0 })
     Howzit::RunReport.log({ topic: 'Git: Clean Repo', task: 'Clean Git Repo', success: false, exit_status: 12 })
     plain = Howzit::RunReport.format.uncolor
-    expect(plain).to include('- [✓] Git: Config: Run Git Origin')
-    expect(plain).to include('- [X] Git: Clean Repo: Clean Git Repo (Failed: exit code 12)')
+    expect(plain).to include('✅')
+    expect(plain).to include('Git: Config: Run Git Origin')
+    expect(plain).to include('❌')
+    expect(plain).to include('Git: Clean Repo: Clean Git Repo')
+    expect(plain).to include('exit code 12')
+  end
+
+  it 'formats as a proper markdown table with aligned columns' do
+    Howzit::RunReport.log({ topic: 'Test', task: 'Short', success: true, exit_status: 0 })
+    Howzit::RunReport.log({ topic: 'Test', task: 'A much longer task name', success: true, exit_status: 0 })
+    plain = Howzit::RunReport.format.uncolor
+    lines = plain.split("\n")
+    # All lines should start and end with pipe
+    lines.each do |line|
+      expect(line).to start_with('|')
+      expect(line).to end_with('|')
+    end
+    # Second line should be separator
+    expect(lines[1]).to match(/^\|[\s:-]+\|[\s:-]+\|$/)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.21
+  version: 2.1.23
 platform: ruby
 authors:
 - Brett Terpstra