markdown_exec 2.0.6 → 2.0.7

data/lib/hash_delegator.rb

@@ -237,6 +237,22 @@ module HashDelegatorSelf
   # @param str [String] The string to be evaluated.
   # @return [Object] The result of evaluating the string.
   def safeval(str)
+    # # Restricting to evaluate only expressions
+    # unless str.match?(/\A\s*\w+\s*[\+\-\*\/\=\%\&\|\<\>\!]+\s*\w+\s*\z/)
+    #   error_handler('safeval') # 'Invalid expression'
+    #   return
+    # end
+
+    # # Whitelisting allowed operations
+    # allowed_methods = %w[+ - * / == != < > <= >= && || % & |]
+    # unless allowed_methods.any? { |op| str.include?(op) }
+    #   error_handler('safeval', 'Operation not allowed')
+    #   return
+    # end
+
+    # # Sanitize input (example: removing potentially harmful characters)
+    # str = str.gsub(/[^0-9\+\-\*\/\(\)\<\>\!\=\%\&\|]/, '')
+    # Evaluate the sanitized string
     result = nil
     binding.eval("result = #{str}")
 
@@ -248,6 +264,16 @@ module HashDelegatorSelf
     exit 1
   end
 
+  # # Evaluates the given string as Ruby code and rescues any StandardErrors.
+  # # If an error occurs, it calls the error_handler method with 'safeval'.
+  # # @param str [String] The string to be evaluated.
+  # # @return [Object] The result of evaluating the string.
+  # def safeval(str)
+  #   eval(str)
+  # rescue StandardError # catches NameError, StandardError
+  #   error_handler('safeval')
+  # end
+
   def set_file_permissions(file_path, chmod_value)
     File.chmod(chmod_value, file_path)
   end
@@ -388,6 +414,74 @@ class BashCommentFormatter
   # end
 end
 
+class StringWrapper
+  attr_reader :width, :left_margin, :right_margin, :indent, :fill_margin
+
+  # Initializes the StringWrapper with the given options.
+  #
+  # @param width [Integer] the maximum width of each line
+  # @param left_margin [Integer] the number of spaces for the left margin
+  # @param right_margin [Integer] the number of spaces for the right margin
+  # @param indent [Integer] the number of spaces to indent all but the first line
+  # @param fill_margin [Boolean] whether to fill the left margin with spaces
+  def initialize(
+    width:,
+    fill_margin: false,
+    first_indent: '',
+    indent_space: '  ',
+    left_margin: 0,
+    margin_char: ' ',
+    rest_indent: '',
+    right_margin: 0
+  )
+    @fill_margin = fill_margin
+    @first_indent = first_indent
+    @indent = indent
+    @indent_space = indent_space
+    @rest_indent = rest_indent
+    @right_margin = right_margin
+    @width = width
+
+    @margin_space = fill_margin ? (margin_char * left_margin) : ''
+    @left_margin = @margin_space.length
+  end
+
+  # Wraps the given text according to the specified options.
+  #
+  # @param text [String] the text to wrap
+  # @return [String] the wrapped text
+  def wrap(text)
+    text = text.dup if text.frozen?
+    max_line_length = width - left_margin - right_margin - @indent_space.length
+    lines = []
+    current_line = String.new
+
+    words = text.split
+    words.each.with_index do |word, index|
+      trial_length = word.length
+      trial_length += @first_indent.length if index.zero?
+      trial_length += current_line.length + 1 + @rest_indent.length if index != 0
+      if trial_length > max_line_length && (words.count != 0)
+        lines << current_line
+        current_line = word
+        current_line = current_line.dup if current_line.frozen?
+      else
+        current_line << ' ' unless current_line.empty?
+        current_line << word
+      end
+    end
+    lines << current_line unless current_line.empty?
+
+    lines.map.with_index do |line, index|
+      @margin_space + if index.zero?
+                        @first_indent
+                      else
+                        @rest_indent
+                      end + line
+    end
+  end
+end
+
 module MarkdownExec
   class DebugHelper
     # Class-level variable to store history of printed messages
@@ -497,6 +591,9 @@ module MarkdownExec
       when MenuState::SAVE
         option_name = @delegate_object[:menu_option_save_name]
         insert_at_top = @delegate_object[:menu_load_at_top]
+      when MenuState::SHELL
+        option_name = @delegate_object[:menu_option_shell_name]
+        insert_at_top = @delegate_object[:menu_load_at_top]
       when MenuState::VIEW
         option_name = @delegate_object[:menu_option_view_name]
         insert_at_top = @delegate_object[:menu_load_at_top]
@@ -595,6 +692,8 @@ module MarkdownExec
     #
     # @return [Array<FCB>] An array of FCB objects representing the blocks.
     def blocks_from_nested_files
+      register_console_attributes(@delegate_object)
+
       blocks = []
       iter_blocks_from_nested_files do |btype, fcb|
         process_block_based_on_type(blocks, btype, fcb)
@@ -605,10 +704,12 @@ module MarkdownExec
       HashDelegator.error_handler('blocks_from_nested_files')
     end
 
+    # find a block by its original (undecorated) name or nickname (not visible in menu)
+    # if matched, the block returned has properties that it is from cli and not ui
     def block_state_for_name_from_cli(block_name)
       SelectedBlockMenuState.new(
         @dml_blocks_in_file.find do |item|
-          item[:oname] == block_name
+          block_name == item.pub_name
         end&.merge(
           block_name_from_cli: true,
           block_name_from_ui: false
@@ -663,7 +764,7 @@ module MarkdownExec
     # @return [Array<String>] Required code blocks as an array of lines.
     def collect_required_code_lines(mdoc:, selected:, block_source:, link_state: LinkState.new)
       required = mdoc.collect_recursively_required_code(
-        anyname: selected[:nickname] || selected[:oname],
+        anyname: selected.pub_name,
         label_format_above: @delegate_object[:shell_code_label_format_above],
         label_format_below: @delegate_object[:shell_code_label_format_below],
         block_source: block_source
@@ -701,47 +802,15 @@ module MarkdownExec
         system(
           format(
             @delegate_object[:execute_command_format],
-            {
-              batch_index: @run_state.batch_index,
-              batch_random: @run_state.batch_random,
-              block_name: @delegate_object[:block_name],
-              document_filename: File.basename(@delegate_object[:filename]),
-              document_filespec: @delegate_object[:filename],
-              home: Dir.pwd,
-              output_filename: File.basename(@delegate_object[:logged_stdout_filespec]),
-              output_filespec: @delegate_object[:logged_stdout_filespec],
-              script_filename: @run_state.saved_filespec,
-              script_filespec: File.join(Dir.pwd, @run_state.saved_filespec),
-              started_at: @run_state.started_at.strftime(
-                @delegate_object[:execute_command_title_time_format]
-              )
-            }
+            command_execute_in_own_window_format_arguments
           )
         )
 
       else
         @run_state.in_own_window = false
-        Open3.popen3(@delegate_object[:shell],
-                     '-c', command,
-                     @delegate_object[:filename],
-                     *args) do |stdin, stdout, stderr, exec_thr|
-          handle_stream(stream: stdout, file_type: ExecutionStreams::STD_OUT) do |line|
-            yield nil, line, nil, exec_thr if block_given?
-          end
-          handle_stream(stream: stderr, file_type: ExecutionStreams::STD_ERR) do |line|
-            yield nil, nil, line, exec_thr if block_given?
-          end
-
-          in_thr = handle_stream(stream: $stdin, file_type: ExecutionStreams::STD_IN) do |line|
-            stdin.puts(line)
-            yield line, nil, nil, exec_thr if block_given?
-          end
-
-          wait_for_stream_processing
-          exec_thr.join
-          sleep 0.1
-          in_thr.kill if in_thr&.alive?
-        end
+        execute_command_with_streams(
+          [@delegate_object[:shell], '-c', command, @delegate_object[:filename], *args]
+        )
       end
 
       @run_state.completed_at = Time.now.utc
@@ -761,6 +830,24 @@ module MarkdownExec
       @fout.fout "Error ENOENT: #{err.inspect}"
     end
 
+    def command_execute_in_own_window_format_arguments(home: Dir.pwd)
+      {
+        batch_index: @run_state.batch_index,
+        batch_random: @run_state.batch_random,
+        block_name: @delegate_object[:block_name],
+        document_filename: File.basename(@delegate_object[:filename]),
+        document_filespec: @delegate_object[:filename],
+        home: home,
+        output_filename: File.basename(@delegate_object[:logged_stdout_filespec]),
+        output_filespec: @delegate_object[:logged_stdout_filespec],
+        script_filename: @run_state.saved_filespec,
+        script_filespec: File.join(home, @run_state.saved_filespec),
+        started_at: @run_state.started_at.strftime(
+          @delegate_object[:execute_command_title_time_format]
+        )
+      }
+    end
+
     # This method is responsible for handling the execution of generic blocks in a markdown document.
     # It collects the required code lines from the document and, depending on the configuration,
     # may display the code for user approval before execution. It then executes the approved block.
@@ -816,16 +903,70 @@ module MarkdownExec
     # @param match_data [MatchData] The match data containing named captures for formatting.
     # @param format_option [String] The format string to be used for the new block.
     # @param color_method [Symbol] The color method to apply to the block's display name.
-    def create_and_add_chrome_block(blocks:, match_data:, format_option:,
-                                    color_method:)
-      oname = format(format_option,
-                     match_data.named_captures.transform_keys(&:to_sym))
-      blocks.push FCB.new(
-        chrome: true,
-        disabled: '',
-        dname: oname.send(color_method),
-        oname: oname
-      )
+    # return number of lines added
+    def create_and_add_chrome_block(blocks:, match_data:,
+                                    format_option:, color_method:,
+                                    case_conversion: nil,
+                                    center: nil,
+                                    wrap: nil)
+      line_cap = match_data.named_captures.transform_keys(&:to_sym)
+
+      # replace tabs in indent
+      line_cap[:indent] ||= ''
+      line_cap[:indent] = line_cap[:indent].dup if line_cap[:indent].frozen?
+      line_cap[:indent].gsub!("\t", '    ')
+      # replace tabs in text
+      line_cap[:text] ||= ''
+      line_cap[:text] = line_cap[:text].dup if line_cap[:text].frozen?
+      line_cap[:text].gsub!("\t", '    ')
+      # missing capture
+      line_cap[:line] ||= ''
+
+      accepted_width = @delegate_object[:console_width] - 2
+      line_caps = if wrap
+                    if line_cap[:text].length > accepted_width
+                      wrapper = StringWrapper.new(width: accepted_width - line_cap[:indent].length)
+                      wrapper.wrap(line_cap[:text]).map do |line|
+                        line_cap.dup.merge(text: line)
+                      end
+                    else
+                      [line_cap]
+                    end
+                  else
+                    [line_cap]
+                  end
+      if center
+        line_caps.each do |line_obj|
+          line_obj[:indent] = if line_obj[:text].length < accepted_width
+                                ' ' * ((accepted_width - line_obj[:text].length) / 2)
+                              else
+                                ''
+                              end
+        end
+      end
+
+      line_caps.each do |line_obj|
+        next if line_obj[:text].nil?
+
+        case case_conversion
+        when :upcase
+          line_obj[:text].upcase!
+        when :downcase
+          line_obj[:text].downcase!
+        end
+
+        # format expects :line to be text only
+        line_obj[:line] = line_obj[:text]
+        oname = format(format_option, line_obj)
+        line_obj[:line] = line_obj[:indent] + line_obj[:text]
+        blocks.push FCB.new(
+          chrome: true,
+          disabled: '',
+          dname: line_obj[:indent] + oname.send(color_method),
+          oname: line_obj[:text]
+        )
+      end
+      line_caps.count
     end
 
     ##
@@ -836,12 +977,12 @@ module MarkdownExec
     # @param use_chrome [Boolean] Indicates if the chrome styling should be applied.
     def create_and_add_chrome_blocks(blocks, fcb)
       match_criteria = [
-        { color: :menu_heading1_color, format: :menu_heading1_format, match: :heading1_match },
-        { color: :menu_heading2_color, format: :menu_heading2_format, match: :heading2_match },
-        { color: :menu_heading3_color, format: :menu_heading3_format, match: :heading3_match },
+        { color: :menu_heading1_color, format: :menu_heading1_format, match: :heading1_match, center: true, case_conversion: :upcase, wrap: true },
+        { color: :menu_heading2_color, format: :menu_heading2_format, match: :heading2_match, center: true, wrap: true },
+        { color: :menu_heading3_color, format: :menu_heading3_format, match: :heading3_match, center: true, case_conversion: :downcase, wrap: true },
         { color: :menu_divider_color,  format: :menu_divider_format,  match: :menu_divider_match },
-        { color: :menu_note_color,     format: :menu_note_format,     match: :menu_note_match },
-        { color: :menu_task_color,     format: :menu_task_format,     match: :menu_task_match }
+        { color: :menu_note_color,     format: :menu_note_format,     match: :menu_note_match, wrap: true },
+        { color: :menu_task_color,     format: :menu_task_format,     match: :menu_task_match, wrap: true }
       ]
       # rubocop:enable Style/UnlessElse
       match_criteria.each do |criteria|
@@ -852,9 +993,12 @@ module MarkdownExec
 
         create_and_add_chrome_block(
           blocks: blocks,
-          match_data: mbody,
+          case_conversion: criteria[:case_conversion],
+          center: criteria[:center],
+          color_method: @delegate_object[criteria[:color]].to_sym,
           format_option: @delegate_object[criteria[:format]],
-          color_method: @delegate_object[criteria[:color]].to_sym
+          match_data: mbody,
+          wrap: criteria[:wrap]
         )
         break
       end
@@ -950,6 +1094,7 @@ module MarkdownExec
         block_name: @delegate_object[:block_name],
         document_filename: @delegate_object[:filename]
       )
+      # @dml_link_state_block_name_from_cli = @dml_link_state.block_name.present? ###
       @run_state.block_name_from_cli = @dml_link_state.block_name.present?
       @cli_block_name = @dml_link_state.block_name
       @dml_now_using_cli = @run_state.block_name_from_cli
@@ -975,6 +1120,7 @@ module MarkdownExec
       item_edit = format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_edit_name]))
       item_load = format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_load_name]))
       item_save = format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_save_name]))
+      item_shell = format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_shell_name]))
       item_view = format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_view_name]))
 
       @run_state.batch_random = Random.new.rand
@@ -999,10 +1145,11 @@ module MarkdownExec
 
             # add menu items (glob, load, save) and enable selectively
             menu_add_disabled_option(sf) if files.count.positive? || lines_count.positive?
-            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_load_name])), files.count, 'files', menu_state: MenuState::LOAD)
-            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_edit_name])), lines_count, 'lines', menu_state: MenuState::EDIT)
-            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_save_name])), lines_count, 'lines', menu_state: MenuState::SAVE)
-            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_view_name])), lines_count, 'lines', menu_state: MenuState::VIEW)
+            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_load_name])), files.count, 'files', menu_state: MenuState::LOAD) if files.count.positive?
+            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_edit_name])), lines_count, 'lines', menu_state: MenuState::EDIT) if lines_count.positive?
+            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_save_name])), 1, '', menu_state: MenuState::SAVE) if lines_count.positive?
+            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_view_name])), 1, '', menu_state: MenuState::VIEW) if lines_count.positive?
+            menu_enable_option(format(@delegate_object[:menu_link_format], HashDelegator.safeval(@delegate_object[:menu_option_shell_name])), 1, '', menu_state: MenuState::SHELL) if @delegate_object[:menu_with_shell]
           end
 
         when :display_menu
@@ -1015,7 +1162,7 @@ module MarkdownExec
           if @dml_link_state.block_name.present?
             # @prior_block_was_link = true
             @dml_block_state.block = @dml_blocks_in_file.find do |item|
-              item[:oname] == @dml_link_state.block_name
+              item.pub_name == @dml_link_state.block_name
             end
             @dml_link_state.block_name = nil
           else
@@ -1024,8 +1171,7 @@ module MarkdownExec
             break if @dml_block_state.block.nil? # no block matched
           end
           # puts "! - Executing block: #{data}"
-          # @dml_block_state.block[:oname]
-          @dml_block_state.block&.fetch(:oname, nil)
+          @dml_block_state.block&.pub_name
 
         when :execute_block
           case (block_name = data)
@@ -1045,6 +1191,7 @@ module MarkdownExec
             )
 
           when item_edit
+            debounce_reset
             edited = edit_text(@dml_link_state.inherited_lines.join("\n"))
             @dml_link_state.inherited_lines = edited.split("\n") if edited
             InputSequencer.next_link_state(prior_block_was_link: true)
@@ -1070,10 +1217,28 @@ module MarkdownExec
               return :break
 
             end
+            InputSequencer.next_link_state(prior_block_was_link: true)
 
+          when item_shell
+            debounce_reset
+            loop do
+              command = prompt_for_command(":MDE #{Time.now.strftime('%FT%TZ')}> ".bgreen)
+              break if !command.present? || command == 'exit'
+
+              exit_status = execute_command_with_streams(
+                [@delegate_object[:shell], '-c', command]
+              )
+              case exit_status
+              when 0
+                warn "#{'OK'.green} #{exit_status}"
+              else
+                warn "#{'ERR'.bred} #{exit_status}"
+              end
+            end
             InputSequencer.next_link_state(prior_block_was_link: true)
 
           when item_view
+            debounce_reset
             warn @dml_link_state.inherited_lines.join("\n")
             InputSequencer.next_link_state(prior_block_was_link: true)
 
@@ -1103,7 +1268,7 @@ module MarkdownExec
               @dml_link_state.block_name, @run_state.block_name_from_cli, cli_break = \
                 HashDelegator.next_link_state(
                   block_name: @dml_link_state.block_name,
-                  block_name_from_cli: !@dml_link_state.block_name.present?,
+                  block_name_from_cli: @dml_now_using_cli,
                   block_state: @dml_block_state,
                   was_using_cli: @dml_now_using_cli
                 )
@@ -1244,6 +1409,53 @@ module MarkdownExec
       #.tap { |ret| pp [__FILE__,__LINE__,'exec_bash_next_state()',ret] }
     end
 
+    # Executes a given command and processes its input, output, and error streams.
+    #
+    # @param [Array<String>] command the command to execute along with its arguments.
+    # @yield [stdin, stdout, stderr, thread] if a block is provided, it yields input, output, error lines, and the execution thread.
+    # @return [Integer] the exit status of the executed command (0 to 255).
+    #
+    # @example
+    #   status = execute_command_with_streams(['ls', '-la']) do |stdin, stdout, stderr, thread|
+    #     puts "STDOUT: #{stdout}" if stdout
+    #     puts "STDERR: #{stderr}" if stderr
+    #   end
+    #   puts "Command exited with status: #{status}"
+    def execute_command_with_streams(command)
+      exit_status = nil
+
+      Open3.popen3(*command) do |stdin, stdout, stderr, exec_thread|
+        # Handle stdout stream
+        handle_stream(stream: stdout, file_type: ExecutionStreams::STD_OUT) do |line|
+          yield nil, line, nil, exec_thread if block_given?
+        end
+
+        # Handle stderr stream
+        handle_stream(stream: stderr, file_type: ExecutionStreams::STD_ERR) do |line|
+          yield nil, nil, line, exec_thread if block_given?
+        end
+
+        # Handle stdin stream
+        input_thread = handle_stream(stream: $stdin, file_type: ExecutionStreams::STD_IN) do |line|
+          stdin.puts(line)
+          yield line, nil, nil, exec_thread if block_given?
+        end
+
+        # Wait for all streams to be processed
+        wait_for_stream_processing
+        exec_thread.join
+
+        # Ensure the input thread is killed if it's still alive
+        sleep 0.1
+        input_thread.kill if input_thread&.alive?
+
+        # Retrieve the exit status
+        exit_status = exec_thread.value.exitstatus
+      end
+
+      exit_status
+    end
+
     # Executes a block of code that has been approved for execution.
     # It sets the script block name, writes command files if required, and handles the execution
     # including output formatting and summarization.
@@ -1294,7 +1506,7 @@ module MarkdownExec
         ### options_state.load_file_link_state
         link_state = LinkState.new
         link_history_push_and_next(
-          curr_block_name: selected[:oname],
+          curr_block_name: selected.pub_name,
           curr_document_filename: @delegate_object[:filename],
           inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies: (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
@@ -1310,7 +1522,7 @@ module MarkdownExec
         code_lines = set_environment_variables_for_block(selected)
         dependencies = {}
         link_history_push_and_next(
-          curr_block_name: selected[:oname],
+          curr_block_name: selected.pub_name,
           curr_document_filename: @delegate_object[:filename],
           inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies: (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
@@ -1437,7 +1649,7 @@ module MarkdownExec
         return
       end
 
-      @delegate_object[:block_name] = block_state.block[:oname]
+      @delegate_object[:block_name] = block_state.block.pub_name
       @menu_user_clicked_back_link = block_state.state == MenuState::BACK
     end
 
@@ -1446,7 +1658,7 @@ module MarkdownExec
         Thread.new do
           stream.each_line do |line|
             line.strip!
-            @run_state.files[file_type] << line
+            @run_state.files[file_type] << line if @run_state.files
 
             if @delegate_object[:output_stdout]
               # print line
@@ -1546,23 +1758,7 @@ module MarkdownExec
 
         if link_block_data.fetch(LinkKeys::EXEC, false)
           @run_state.files = Hash.new([])
-
-          Open3.popen3(cmd) do |stdin, stdout, stderr, _exec_thr|
-            handle_stream(stream: stdout, file_type: ExecutionStreams::STD_OUT) do |line|
-              output_lines.push(line)
-            end
-            handle_stream(stream: stderr, file_type: ExecutionStreams::STD_ERR) do |line|
-              output_lines.push(line)
-            end
-
-            in_thr = handle_stream(stream: $stdin, file_type: ExecutionStreams::STD_IN) do |line|
-              stdin.puts(line)
-            end
-
-            wait_for_stream_processing
-            sleep 0.1
-            in_thr.kill if in_thr&.alive?
-          end
+          execute_command_with_streams([cmd])
 
           ## select output_lines that look like assignment or match other specs
           #
@@ -1585,13 +1781,13 @@ module MarkdownExec
       label_format_below = @delegate_object[:shell_code_label_format_below]
 
       [label_format_above && format(label_format_above,
-                                    block_source.merge({ block_name: selected[:oname] }))] +
+                                    block_source.merge({ block_name: selected.pub_name }))] +
         output_lines.map do |line|
           re = Regexp.new(link_block_data.fetch('pattern', '(?<line>.*)'))
           re.gsub_format(line, link_block_data.fetch('format', '%{line}')) if re =~ line
         end.compact +
         [label_format_below && format(label_format_below,
-                                      block_source.merge({ block_name: selected[:oname] }))]
+                                      block_source.merge({ block_name: selected.pub_name }))]
     end
 
     def link_history_push_and_next(
@@ -1655,7 +1851,7 @@ module MarkdownExec
     def load_cli_or_user_selected_block(all_blocks: [], menu_blocks: [], default: nil)
       if @delegate_object[:block_name].present?
         block = all_blocks.find do |item|
-          item[:oname] == @delegate_object[:block_name]
+          item.pub_name == @delegate_object[:block_name]
         end&.merge(block_name_from_ui: false)
       else
         block_state = wait_for_user_selected_block(all_blocks, menu_blocks,
@@ -1682,6 +1878,44 @@ module MarkdownExec
         expanded_expression
       end
     end
+
+    # private
+
+    # def read_block_name(line)
+    #   bm = extract_named_captures_from_option(line, @delegate_object[:block_name_match])
+    #   name = bm[:title]
+
+    #   if @delegate_object[:block_name_nick_match].present? && line =~ Regexp.new(@delegate_object[:block_name_nick_match])
+    #     name = $~[0]
+    #   else
+    #     name = bm && bm[1] ? bm[:title] : name
+    #   end
+    #   name
+    # end
+
+    #     # Loads auto link block.
+    #     def load_auto_link_block(all_blocks, link_state, mdoc, block_source:)
+    #       block_name = @delegate_object[:document_load_link_block_name]
+    #       return unless block_name.present? && @most_recent_loaded_filename != @delegate_object[:filename]
+
+    #       block = HashDelegator.block_find(all_blocks, :oname, block_name)
+    #       return unless block
+
+    #       if block.fetch(:shell, '') != BlockType::LINK
+    #         HashDelegator.error_handler('must be Link block type', { abort: true })
+
+    #       else
+    #         # debounce_reset
+    #         push_link_history_and_trigger_load(
+    #           link_block_body: block.fetch(:body, ''),
+    #           mdoc: mdoc,
+    #           selected: block,
+    #           link_state: link_state,
+    #           block_source: block_source
+    #         )
+    #       end
+    #     end
+
     # Handle expression with wildcard characters
     def load_filespec_wildcard_expansion(expr, auto_load_single: false)
       files = find_files(expr)
@@ -1717,6 +1951,7 @@ module MarkdownExec
       # recreate menu with new options
       #
       all_blocks, mdoc = mdoc_and_blocks_from_nested_files if load_auto_opts_block(all_blocks)
+      # load_auto_link_block(all_blocks, link_state, mdoc, block_source: {})
 
       menu_blocks = mdoc.fcbs_per_options(@delegate_object)
       add_menu_chrome_blocks!(menu_blocks: menu_blocks, link_state: link_state)
@@ -1793,7 +2028,7 @@ module MarkdownExec
       #
       return unless item
 
-      item[:dname] = "#{name} (#{count} #{type})"
+      item[:dname] = type.present? ? "#{name} (#{count} #{type})" : name
       if count.positive?
         item.delete(:disabled)
       else
@@ -1902,7 +2137,7 @@ module MarkdownExec
       else
         # no history exists; must have been called independently => retain script
         link_history_push_and_next(
-          curr_block_name: selected[:oname],
+          curr_block_name: selected.pub_name,
           curr_document_filename: @delegate_object[:filename],
           inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies: (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
@@ -2036,6 +2271,14 @@ module MarkdownExec
       exit 1
     end
 
+    def prompt_for_command(prompt)
+      print prompt
+
+      gets.chomp
+    rescue Interrupt
+      nil
+    end
+
     # Prompts the user to enter a path or name to substitute into the wildcard expression.
     # If interrupted by the user (e.g., pressing Ctrl-C), it returns nil.
     #
@@ -2132,8 +2375,7 @@ module MarkdownExec
     # user prompt to exit if the menu will be displayed again
     #
     def prompt_user_exit(block_name_from_cli:, selected:)
-      !block_name_from_cli &&
-        selected[:shell] == BlockType::BASH &&
+      selected[:shell] == BlockType::BASH &&
         @delegate_object[:pause_after_script_execution] &&
         prompt_select_continue == MenuState::EXIT
     end
@@ -2154,7 +2396,7 @@ module MarkdownExec
       #
       if mdoc
         code_info = mdoc.collect_recursively_required_code(
-          anyname: selected[:oname],
+          anyname: selected.pub_name,
           label_format_above: @delegate_object[:shell_code_label_format_above],
           label_format_below: @delegate_object[:shell_code_label_format_below],
           block_source: block_source
@@ -2171,7 +2413,7 @@ module MarkdownExec
       # load key and values from link block into current environment
       #
       if link_block_data[LinkKeys::VARS]
-        code_lines.push BashCommentFormatter.format_comment(selected[:oname])
+        code_lines.push BashCommentFormatter.format_comment(selected.pub_name)
         (link_block_data[LinkKeys::VARS] || []).each do |(key, value)|
           ENV[key] = value.to_s
           code_lines.push(assign_key_value_in_bash(key, value))
@@ -2200,7 +2442,7 @@ module MarkdownExec
 
       else
         link_history_push_and_next(
-          curr_block_name: selected[:oname],
+          curr_block_name: selected.pub_name,
           curr_document_filename: @delegate_object[:filename],
           inherited_block_names: ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies: (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
@@ -2243,6 +2485,16 @@ module MarkdownExec
                      ))
     end
 
+    def register_console_attributes(opts)
+      unless opts[:console_width]
+        require 'io/console'
+        opts[:console_height], opts[:console_width] = opts[:console_winsize] = IO.console.winsize
+      end
+      opts[:per_page] = opts[:select_page_height] = [opts[:console_height] - 3, 4].max unless opts[:select_page_height]&.positive?
+    rescue StandardError
+      HashDelegator.error_handler('register_console_attributes', { abort: true })
+    end
+
     # Check if the delegate object responds to a given method.
     # @param method_name [Symbol] The name of the method to check.
     # @param include_private [Boolean] Whether to include private methods in the check.
@@ -2323,10 +2575,7 @@ module MarkdownExec
     def select_option_with_metadata(prompt_text, names, opts = {})
       ## configure to environment
       #
-      unless opts[:select_page_height].positive?
-        require 'io/console'
-        opts[:per_page] = opts[:select_page_height] = [IO.console.winsize[0] - 3, 4].max
-      end
+      register_console_attributes(opts)
 
       # crashes if all menu options are disabled
       selection = @prompt.select(prompt_text,
@@ -2528,6 +2777,8 @@ module MarkdownExec
       @process_mutex.synchronize do
         @process_cv.wait(@process_mutex)
       end
+    rescue Interrupt
+      # user interrupts process
     end
 
     def wait_for_user_selected_block(all_blocks, menu_blocks, default)
@@ -2568,7 +2819,7 @@ module MarkdownExec
       time_now = Time.now.utc
       @run_state.saved_script_filename =
         SavedAsset.script_name(
-          blockname: selected[:nickname] || selected[:oname],
+          blockname: selected.pub_name,
           filename: @delegate_object[:filename],
           prefix: @delegate_object[:saved_script_filename_prefix],
           time: time_now
@@ -2661,6 +2912,21 @@ module MarkdownExec
 
     def self.next_link_state(*args, **kwargs, &block)
       super
+      # result = super
+
+      # @logger ||= StdOutErrLogger.new
+      # @logger.unknown(
+      #   HashDelegator.clean_hash_recursively(
+      #     { "HashDelegator.next_link_state":
+      #         { 'args': args,
+      #           'at': Time.now.strftime('%FT%TZ'),
+      #           'for': /[^\/]+:\d+/.match(caller.first)[0],
+      #           'kwargs': kwargs,
+      #           'return': result } }
+      #   )
+      # )
+
+      # result
     end
   end
 end
@@ -2912,7 +3178,6 @@ module MarkdownExec
 
       def test_blocks_from_nested_files
         result = @hd.blocks_from_nested_files
-
         assert_kind_of Array, result
         assert_kind_of FCB, result.first
       end