howzit 2.1.47 → 2.1.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 477bc94918f7906d52412423ee73992f2d255279d757f36d0feed85f74c1f454
-  data.tar.gz: 926727bfe69e059367fa75d4b55b095786663487cdc8f311b13ee92dd44d15e0
+  metadata.gz: 91e3e382d6e58e8a3a50cb663de149af066ee02b80bafcdbf6db5d68c79426af
+  data.tar.gz: ebaf51a69ba374ba5fa64a548560cfa0b8e03f70b85a77de3a1f43aa94baf944
 SHA512:
-  metadata.gz: 8f4c4228bc522c7608f77d0ab4e7f4f802753e71c7f37d2f41d9f81e01764a8b0b285aaed8bc5bad6a9ccaa0544d83007bde4c7aea7c0e41bc2fc834bb8304d7
-  data.tar.gz: a24505c7b3f22f7d4bb52eb91372f44d0ef200285faf4006bb8a93588bdb63318063d26b5571026374f8f67b648678d0bd4edf4223c5561c39ad625ec2a08a69
+  metadata.gz: 96e353abbe3fec9eb5cce2c1fcbbdc45d425394594f394251dc2719937ba69a2acbf87e7d3ccae437baf25b33c400ef0ddf7c01cd42765cc4f39009968f703cf
+  data.tar.gz: 48c8b7253abbd0adfe88a0b5ccb1108684db73252c87823ef29aa59507feefd814bc689831585255e73624136f55cd39ee0797ab84666c49dc3a56107b76fa31

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+### 2.1.49
+
+2026-10-21 05:15
+
+#### CHANGED
+
+- **Markdown highlighting** tries `apex` first when `:highlighter:` is `auto`, then mdcat, then mdless. mdless is still installed with the gem
+- **Directives inside a code fence** are shown as code instead of being turned into tasks
+
+#### FIXED
+
+- **Apex output** uses `-t terminal256 --no-paginate`, including when `:highlighter:` is set to `apex` alone, so topics render as terminal color instead of HTML
+- **Placeholders inside fenced code** are left as written, so a syntax highlighter such as Pygments does not print howzit's color codes as text like `[1m`
+
+### 2.1.48
+
+2026-10-09 07:20
+
+#### CHANGED
+
+- **@before blocks** from a topic, its subtopics, and any included topics are shown together in one box before anything runs, with a single confirmation prompt instead of one prompt per topic
+- **@after blocks** from a topic, its subtopics, and any included topics are shown together in one box at the end of the run instead of after each topic finishes
+
+#### IMPROVED
+
+- **Collected notes** appear in document order: the topic's own block, then included topics in @include order, then subtopics
+- **@after notes from subtopics skipped after a failure** are still shown in the final box
+- **Notes from included topics** render variables with the bracketed arguments passed via @include(Topic [args])
+- **@before blocks** now render ${variables}, matching @after
+- **Topics included more than once** only contribute their notes once
+
 ### 2.1.47
 
 2026-09-27 13:20

data/README.md

@@ -37,7 +37,7 @@ Howzit is a tool that allows you to keep Markdown-formatted notes about a projec
 - Ruby 2.4+ (It probably works on older Rubys, but is untested prior to 2.4.1.)
 - Optional: if [`fzf`](https://github.com/junegunn/fzf) is available, it will be used for handling multiple choice selections
 - Optional: if [`bat`](https://github.com/sharkdp/bat) is available it will page with that
-- Optional: [`mdless`](https://github.com/ttscoff/mdless) or [`mdcat`](https://github.com/lunaryorn/mdcat) for formatting output
+- Optional: [`apex`](https://github.com/ApexMarkdown/apex) is preferred for formatting output when it is installed. Otherwise howzit uses [`mdcat`](https://github.com/lunaryorn/mdcat) or [`mdless`](https://github.com/ttscoff/mdless). mdless is installed with the howzit gem.
 
 ### Installing
 

data/bin/howzit

@@ -210,7 +210,7 @@ OptionParser.new do |opts|
     Howzit.options[:header_format] = t
   end
 
-  opts.on('--[no-]md-highlight', 'Highlight Markdown syntax (default on), requires mdless or mdcat') do |m|
+  opts.on('--[no-]md-highlight', 'Highlight Markdown syntax (default on), prefers apex, then mdcat or mdless') do |m|
     Howzit.options[:highlight] = Howzit.options[:color] ? m : false
   end
 

data/lib/howzit/task.rb

@@ -6,7 +6,7 @@ module Howzit
   # Task object
   class Task
     attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level, :source_file,
-                :include_results
+                :include_results, :include_args
 
     ##
     ## Initialize a Task object

data/lib/howzit/topic.rb

@@ -165,34 +165,58 @@ module Howzit
     ## @return     [Array] output lines
     ##
     def run(nested: false, as_subtopic: false)
-      @results = { total: 0, success: 0, errors: 0, message: ''.c }
-      output = []
-      cols = check_cols
-
-      confirm_prereqs(cols) if !@prereqs.empty? && (all_tasks.any? || sequential?)
-
-      if sequential?
-        run_sequential(output: output)
-      elsif @tasks.any?
-        run_tasks(output)
-      elsif all_tasks.empty? && !as_subtopic && !directives?
-        Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
-      end
+      # The outermost run shows @before/@after notes for the whole tree
+      return run_topic(nested: nested, as_subtopic: as_subtopic) if Howzit.topic_run_active
 
-      if halted?
-        log_skipped_tasks(@subtopics.flat_map(&:all_tasks))
-      else
-        run_subtopics(output)
+      Howzit.topic_run_active = true
+      begin
+        cols = check_cols
+        confirm_prereqs(cols) if all_tasks.any? || sequential?
+        output = run_topic(nested: nested, as_subtopic: as_subtopic)
+        show_postreqs(cols)
+        output
+      ensure
+        Howzit.topic_run_active = false
       end
+    end
 
-      if @results[:total].positive? || (all_tasks.any? && !sequential?)
-        @results[:message] += results_message
-        output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
-      end
+    ##
+    ## @before notes for this topic, the topics it includes, and its
+    ## subtopics, in document order
+    ##
+    ## @return     [Array] rendered notes
+    ##
+    def all_prereqs
+      collect_notes(:prereqs)
+    end
 
-      show_postreqs(cols)
+    ##
+    ## @after notes for this topic, the topics it includes, and its
+    ## subtopics, in document order
+    ##
+    ## @return     [Array] rendered notes
+    ##
+    def all_postreqs
+      collect_notes(:postreqs)
+    end
 
-      output
+    ##
+    ## Gather notes recursively through @include tasks and subtopics
+    ##
+    ## @param      kind  [Symbol] :prereqs or :postreqs
+    ## @param      args  [Array] Bracketed arguments from an @include
+    ## @param      seen  [Array] Titles of topics already collected
+    ##
+    def collect_notes(kind, args = nil, seen = [])
+      return [] if seen.include?(@title)
+
+      seen << @title
+      notes = render_notes(kind == :prereqs ? @prereqs : @postreqs, args)
+      @tasks.select { |task| task.type == :include }.each do |task|
+        topic = Howzit.buildnote.find_topic(task.action.sub(/ *\[.*?\] *$/, ''))[0]
+        notes.concat(topic.collect_notes(kind, task.include_args, seen)) if topic
+      end
+      notes + @subtopics.flat_map { |sub| sub.collect_notes(kind, nil, seen) }
     end
 
     ##
@@ -215,8 +239,11 @@ module Howzit
     end
 
     def confirm_prereqs(cols)
+      prereqs = all_prereqs
+      return if prereqs.empty?
+
       begin
-        puts TTY::Box.frame("{by}#{@prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
+        puts TTY::Box.frame("{by}#{prereqs.join("\n\n").wrap(cols - 4)}{x}".c, width: cols)
       rescue Errno::EPIPE
         # Pipe closed, ignore
       end
@@ -225,11 +252,11 @@ module Howzit
     end
 
     def show_postreqs(cols)
-      return if @postreqs.empty?
+      postreqs = all_postreqs
+      return if postreqs.empty?
 
-      # Apply variable substitution to postreqs content, then wrap each line individually to preserve structure
-      postreqs_content = @postreqs.join("\n\n").render_arguments
-      wrapped_content = postreqs_content.split(/\n/).map { |line| line.wrap(cols - 4) }.join("\n")
+      # Wrap each line individually to preserve structure
+      wrapped_content = postreqs.join("\n\n").split(/\n/).map { |line| line.wrap(cols - 4) }.join("\n")
       puts TTY::Box.frame("{bw}#{wrapped_content}{x}".c, width: cols)
     rescue Errno::EPIPE
       # Pipe closed, ignore
@@ -466,7 +493,18 @@ module Howzit
         topic.gsub!(/(?mix)^(`{3,})run([?!]*)\s*
                     ([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run\2 \3')
       end
+      in_fence = false
+      fence_char = nil
+      fence_len = 0
       topic.split(/\n/).each do |l|
+        # Fenced code is passed through unchanged. Howzit color codes inside a
+        # fence get mangled by the syntax highlighter Apex shells out to.
+        if in_fence
+          output.push(l)
+          in_fence = false if closing_fence?(l, fence_char, fence_len)
+          next
+        end
+
         case l
         when /@(before|after|prereq|end|if|unless)/
           next
@@ -477,12 +515,22 @@ module Howzit
         when /(?<fence>`{3,})run(?<optional>[!?]{1,2})? *(?<title>.*?)$/i
           desc = title_code_block(Regexp.last_match.named_captures.symbolize_keys)
           output.push("{bmK}\u{25B6} {bwK}#{desc}{x}\n```".c)
+          fence_char = '`'
+          fence_len = Regexp.last_match[:fence].length
+          in_fence = true
         when /@@@run(?<optional>[!?]{1,2})? *(?<title>.*?)$/i
           output.push("{bmK}\u{25B6} {bwK}#{title_code_block(Regexp.last_match.named_captures.symbolize_keys)}{x}".c)
         else
-          l.wrap!(Howzit.options[:wrap]) if Howzit.options[:wrap].positive?
-          # Highlight variable placeholders in content
-          output.push(highlight_variables(l))
+          opened = opening_fence(l)
+          if opened
+            fence_char, fence_len = opened
+            in_fence = true
+            output.push(l)
+          else
+            l.wrap!(Howzit.options[:wrap]) if Howzit.options[:wrap].positive?
+            # Highlight variable placeholders in content
+            output.push(highlight_variables(l))
+          end
         end
       end
       Howzit.named_arguments = @named_args
@@ -593,6 +641,72 @@ module Howzit
 
     private
 
+    ##
+    ## A markdown opening fence (` ``` ` or `~~~`, up to three spaces of indent)
+    ##
+    ## @return     [Array(String, Integer), nil] fence character and length
+    ##
+    def opening_fence(line)
+      match = line.match(/\A {0,3}(?<marker>`{3,}|~{3,})/)
+      return unless match
+
+      marker = match[:marker]
+      [marker[0], marker.length]
+    end
+
+    def closing_fence?(line, char, length)
+      line.match?(/\A {0,3}#{Regexp.escape(char)}{#{length},}[ \t]*\z/)
+    end
+
+    def run_topic(nested:, as_subtopic:)
+      @results = { total: 0, success: 0, errors: 0, message: ''.c }
+      output = []
+
+      if sequential?
+        run_sequential(output: output)
+      elsif @tasks.any?
+        run_tasks(output)
+      elsif all_tasks.empty? && !as_subtopic && !directives?
+        Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
+      end
+
+      if halted?
+        log_skipped_tasks(@subtopics.flat_map(&:all_tasks))
+      else
+        run_subtopics(output)
+      end
+
+      if @results[:total].positive? || (all_tasks.any? && !sequential?)
+        @results[:message] += results_message
+        output.push(@results[:message]) if Howzit.options[:log_level] < 2 && !nested && !Howzit.options[:run]
+      end
+
+      output
+    end
+
+    ##
+    ## Render notes with this topic's variables, plus any bracketed
+    ## @include arguments bound to its title parameters
+    ##
+    def render_notes(notes, args)
+      return [] if notes.empty?
+
+      previous = Howzit.named_arguments
+      begin
+        Howzit.named_arguments = (previous || {}).merge(@named_args.compact).merge(bound_arguments(args))
+        notes.map(&:render_arguments)
+      ensure
+        Howzit.named_arguments = previous
+      end
+    end
+
+    def bound_arguments(args)
+      return {} if args.nil? || args.empty?
+
+      names = @arg_definitions.map { |definition| definition.split(':', 2).first }
+      names.zip(args).to_h.compact
+    end
+
     ##
     ## Collect all directives in the topic content
     ##

data/lib/howzit/util.rb

@@ -50,31 +50,50 @@ module Howzit
         end
       end
 
-      # If either mdless or mdcat are installed, use that for highlighting
-      # markdown
+      # Prefer apex, then mdcat, then mdless. mdless ships with the gem,
+      # so highlighting still works when apex is not installed.
       def which_highlighter
-        if Howzit.options[:highlighter] =~ /auto/i
-          highlighters = %w[mdcat mdless]
-          highlighters.delete_if(&:nil?).select!(&:available?)
-          return nil if highlighters.empty?
+        command = if Howzit.options[:highlighter] =~ /auto/i
+                    auto_highlighter
+                  else
+                    configured_highlighter
+                  end
+        apex_command(command)
+      end
 
-          hl = highlighters.first
-          args = case hl
-                 when 'mdless'
-                   '--no-pager'
-                 end
+      # Apex defaults to HTML. Howzit always wants terminal escapes, and it
+      # pages the result itself, so add those flags unless the command
+      # already sets a format or a pagination option. This covers both
+      # auto and an explicit `:highlighter: apex`.
+      def apex_command(command)
+        return command if command.nil? || command.empty?
+        return command unless command.split.first == 'apex'
 
-          [hl, args].join(' ')
-        else
-          hl = Howzit.options[:highlighter].split(/ /)[0]
-          if hl.available?
-            Howzit.options[:highlighter]
-          else
-            Howzit.console.error Color.template("{Rw}Error:{xbw} Specified highlighter (#{Howzit.options[:highlighter]}) not found, switching to auto")
-            Howzit.options[:highlighter] = 'auto'
-            which_highlighter
-          end
-        end
+        args = command.split[1..]
+        has_format = args.any? { |arg| ['-t', '--to'].include?(arg) || arg.start_with?('--to=') }
+        args.push('-t', 'terminal256') unless has_format
+        has_pager = args.any? { |arg| ['--no-paginate', '--paginate', '-p'].include?(arg) }
+        args << '--no-paginate' unless has_pager
+        ['apex', *args].join(' ')
+      end
+
+      def auto_highlighter
+        highlighters = %w[apex mdcat mdless]
+        highlighters.delete_if(&:nil?).select!(&:available?)
+        return nil if highlighters.empty?
+
+        hl = highlighters.first
+        args = '--no-pager' if hl == 'mdless'
+        [hl, args].compact.join(' ')
+      end
+
+      def configured_highlighter
+        hl = Howzit.options[:highlighter].split(/ /)[0]
+        return Howzit.options[:highlighter] if hl.available?
+
+        Howzit.console.error Color.template("{Rw}Error:{xbw} Specified highlighter (#{Howzit.options[:highlighter]}) not found, switching to auto")
+        Howzit.options[:highlighter] = 'auto'
+        auto_highlighter
       end
 
       # When pagination is enabled, find the best (in my opinion) option,

data/lib/howzit/version.rb

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

data/lib/howzit.rb

@@ -60,7 +60,8 @@ require 'tty/box'
 # Main module for howzit
 module Howzit
   class << self
-    attr_accessor :arguments, :named_arguments, :cli_topic_positional_args, :cli_args, :run_log, :multi_topic_run
+    attr_accessor :arguments, :named_arguments, :cli_topic_positional_args, :cli_args, :run_log, :multi_topic_run,
+                  :topic_run_active
 
     ##
     ## Holds a Configuration object with methods and a @settings hash

data/spec/collected_notes_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'fileutils'
+require 'tmpdir'
+require 'stringio'
+
+describe 'collected @before/@after notes' do
+  let(:temp_dir) { File.expand_path(Dir.mktmpdir('howzit_notes_test')) }
+  let(:out_file) { File.join(temp_dir, 'out.txt') }
+  let(:child_two_command) { 'false' }
+  let(:buildnote) do
+    note = Howzit::BuildNote.new
+    allow(note).to receive(:finalize_output)
+    note
+  end
+
+  before do
+    File.write(
+      File.join(temp_dir, 'buildnotes.md'),
+      <<~NOTE
+        # Notes Project
+
+        ## Parent
+
+        @before
+        Parent before
+        @end
+
+        @run(echo "parent" >> "#{out_file}") Parent task
+
+        @include(Shared [prod])
+
+        @after
+        Parent after
+        @end
+
+        ### Child One
+
+        @before
+        Child before
+        @end
+
+        @run(echo "child" >> "#{out_file}") Child task
+
+        @after
+        Child after
+        @end
+
+        ### Child Two
+
+        @run(#{child_two_command}) Child two task
+
+        ### Child Three
+
+        @run(echo "three" >> "#{out_file}") Three task
+
+        @after
+        Three after
+        @end
+
+        ## Shared (target)
+
+        @run(echo "shared ${target}" >> "#{out_file}") Shared task
+
+        @after
+        Shared after ${target}
+        @end
+      NOTE
+    )
+
+    Dir.chdir(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, buildnote)
+    Howzit.options[:stack] = false
+    Howzit.options[:include_upstream] = false
+    Howzit.options[:run] = true
+    Howzit.options[:force] = false
+    Howzit.options[:log_level] = 3
+    Howzit.cli_args = ['parent']
+    Howzit.run_log = []
+    allow(Howzit::Prompt).to receive(:yn).and_return(true)
+  end
+
+  after do
+    Howzit.options[:run] = false
+    Howzit.options[:log_level] = 1
+    Howzit.cli_args = []
+    Howzit.run_log = []
+    Dir.chdir(Dir.tmpdir)
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+    Howzit.instance_variable_set(:@buildnote, nil)
+  end
+
+  def run_and_capture
+    original = $stdout
+    $stdout = StringIO.new
+    buildnote.run
+    $stdout.string.gsub(/\e\[[\d;]*m/, '')
+  ensure
+    $stdout = original
+  end
+
+  def positions(text, notes)
+    notes.map { |note| text.index(note) }
+  end
+
+  it 'asks once for all prerequisites before running anything' do
+    text = run_and_capture
+
+    expect(Howzit::Prompt).to have_received(:yn).once
+    expect(positions(text, ['Parent before', 'Child before'])).to all(be_a(Integer))
+    expect(text.scan('Parent before').count).to eq 1
+  end
+
+  it 'shows all @after notes together in document order, including included topics' do
+    text = run_and_capture
+
+    notes = ['Parent after', 'Shared after prod', 'Child after', 'Three after']
+    found = positions(text, notes)
+    expect(found).to all(be_a(Integer))
+    expect(found).to eq(found.sort)
+    expect(text.scan('Child after').count).to eq 1
+  end
+
+  it 'shows notes from subtopics skipped after a failure' do
+    text = run_and_capture
+
+    expect(File.read(out_file).lines.map(&:strip)).to eq(['parent', 'shared prod', 'child'])
+    expect(text).to include('Three after')
+  end
+
+  context 'when nothing fails' do
+    let(:child_two_command) { 'true' }
+
+    it 'shows the combined @after box after all tasks have run' do
+      text = run_and_capture
+
+      expect(File.read(out_file).lines.map(&:strip)).to eq(['parent', 'shared prod', 'child', 'three'])
+      expect(text.scan('Parent after').count).to eq 1
+    end
+  end
+end

data/spec/topic_spec.rb

@@ -103,6 +103,36 @@ describe Howzit::Topic do
       Howzit.options[:show_all_code] = true
       expect(topic.print_out({ single: true, header: true }).join("\n").uncolor).to match(/▶ ls -1/)
     end
+
+    it 'leaves placeholders inside fenced code for the syntax highlighter' do
+      Howzit::Color.coloring = true
+      Howzit.options[:show_all_code] = true
+      note = Howzit::Topic.new('Widgets', <<~MD)
+        We set ${TEST_VAR} in a script block
+
+        ```bash
+        echo "${TEST_VAR}"
+        @run(ls) shown as code
+        ```
+
+        ```run Full capture script
+        if [[ -n ${only} ]]
+        ```
+      MD
+
+      lines = note.print_out({ single: true, header: false })
+      prose = lines.find { |line| line.include?('We set') }
+      echo_line = lines.find { |line| line.include?('echo') }
+      directive = lines.find { |line| line.include?('@run') }
+      condition = lines.find { |line| line.include?('only') }
+
+      expect(prose).to include("\e[")
+      expect(echo_line).to eq('echo "${TEST_VAR}"')
+      expect(directive).to eq('@run(ls) shown as code')
+      expect(condition).to eq('if [[ -n ${only} ]]')
+    ensure
+      Howzit::Color.coloring = false
+    end
   end
 
   describe '.arguments' do

data/spec/util_spec.rb

@@ -23,10 +23,50 @@ describe Howzit::Util do
   end
 
   describe '.which_highlighter' do
+    after { Howzit.options[:highlighter] = 'auto' }
+
     it 'finds mdless' do
       Howzit.options[:highlighter] = 'mdless'
       expect(util.which_highlighter).to eq 'mdless'
     end
+
+    it 'prefers apex with terminal256 output and pagination disabled' do
+      Howzit.options[:highlighter] = 'auto'
+      allow(util).to receive(:command_exist?).and_return(false)
+      allow(util).to receive(:command_exist?).with('apex').and_return(true)
+
+      expect(util.which_highlighter).to eq 'apex -t terminal256 --no-paginate'
+    end
+
+    it 'uses mdcat when apex is not installed' do
+      Howzit.options[:highlighter] = 'auto'
+      allow(util).to receive(:command_exist?).and_return(false)
+      allow(util).to receive(:command_exist?).with('mdcat').and_return(true)
+
+      expect(util.which_highlighter).to eq 'mdcat'
+    end
+
+    it 'uses mdless without its pager when apex and mdcat are not installed' do
+      Howzit.options[:highlighter] = 'auto'
+      allow(util).to receive(:command_exist?).and_return(false)
+      allow(util).to receive(:command_exist?).with('mdless').and_return(true)
+
+      expect(util.which_highlighter).to eq 'mdless --no-pager'
+    end
+
+    it 'adds terminal256 output when the highlighter is set to apex' do
+      Howzit.options[:highlighter] = 'apex'
+      allow(util).to receive(:command_exist?).with('apex').and_return(true)
+
+      expect(util.which_highlighter).to eq 'apex -t terminal256 --no-paginate'
+    end
+
+    it 'keeps an explicit apex output format' do
+      Howzit.options[:highlighter] = 'apex -t html'
+      allow(util).to receive(:command_exist?).with('apex').and_return(true)
+
+      expect(util.which_highlighter).to eq 'apex -t html --no-paginate'
+    end
   end
 
   describe '.which_pager' do

data/src/_README.md

@@ -37,7 +37,7 @@ Howzit is a tool that allows you to keep Markdown-formatted notes about a projec
 - Ruby 2.4+ (It probably works on older Rubys, but is untested prior to 2.4.1.)
 - Optional: if [`fzf`](https://github.com/junegunn/fzf) is available, it will be used for handling multiple choice selections
 - Optional: if [`bat`](https://github.com/sharkdp/bat) is available it will page with that
-- Optional: [`mdless`](https://github.com/ttscoff/mdless) or [`mdcat`](https://github.com/lunaryorn/mdcat) for formatting output
+- Optional: [`apex`](https://github.com/ApexMarkdown/apex) is preferred for formatting output when it is installed. Otherwise howzit uses [`mdcat`](https://github.com/lunaryorn/mdcat) or [`mdless`](https://github.com/ttscoff/mdless). mdless is installed with the howzit gem.
 
 ### Installing
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.47
+  version: 2.1.49
 platform: ruby
 authors:
 - Brett Terpstra
@@ -317,6 +317,7 @@ files:
 - scripts/runtests.sh
 - spec/buildnote_spec.rb
 - spec/cli_spec.rb
+- spec/collected_notes_spec.rb
 - spec/condition_evaluator_spec.rb
 - spec/conditional_blocks_integration_spec.rb
 - spec/conditional_content_spec.rb
@@ -367,6 +368,7 @@ summary: Provides a way to access Markdown project notes by topic with query cap
 test_files:
 - spec/buildnote_spec.rb
 - spec/cli_spec.rb
+- spec/collected_notes_spec.rb
 - spec/condition_evaluator_spec.rb
 - spec/conditional_blocks_integration_spec.rb
 - spec/conditional_content_spec.rb