markdown-run 0.1.10 → 0.1.12

data/lib/execution_decider.rb

@@ -3,11 +3,12 @@ require_relative "enum_helper"
 class ExecutionDecider
   include EnumHelper
 
-  def initialize(current_block_run, current_block_rerun, current_block_lang, current_block_explain = false, current_block_result = true)
+  def initialize(current_block_run, current_block_rerun, current_block_lang, current_block_explain = false, current_block_flamegraph = false, current_block_result = true)
     @current_block_run = current_block_run
     @current_block_rerun = current_block_rerun
     @current_block_lang = current_block_lang
     @current_block_explain = current_block_explain
+    @current_block_flamegraph = current_block_flamegraph
     @current_block_result = current_block_result
   end
 
@@ -21,8 +22,10 @@ class ExecutionDecider
       handle_immediate_result_block(file_enum)
     elsif is_blank_line?(peek1)
       handle_blank_line_scenario(file_enum, expected_header_regex)
-    elsif @current_block_explain && is_dalibo_link?(peek1)
+    elsif (@current_block_explain || @current_block_flamegraph) && is_dalibo_link?(peek1)
       handle_immediate_dalibo_link(file_enum)
+    elsif @current_block_flamegraph && is_flamegraph_link?(peek1)
+      handle_immediate_flamegraph_link(file_enum)
     else
       execute_without_existing_result
     end
@@ -48,11 +51,11 @@ class ExecutionDecider
 
   def handle_blank_line_scenario(file_enum, expected_header_regex)
     consumed_blank_line = file_enum.next
-    
+
     # Look ahead past multiple blank lines to find actual content
     peek2 = peek_next_line(file_enum)
     additional_blanks = []
-    
+
     # Consume consecutive blank lines
     while is_blank_line?(peek2)
       additional_blanks << file_enum.next
@@ -61,8 +64,10 @@ class ExecutionDecider
 
     if line_matches_pattern?(peek2, expected_header_regex)
       handle_result_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
-    elsif @current_block_explain && is_dalibo_link?(peek2)
+    elsif (@current_block_explain || @current_block_flamegraph) && is_dalibo_link?(peek2)
       handle_dalibo_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    elsif @current_block_flamegraph && is_flamegraph_link?(peek2)
+      handle_flamegraph_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
     else
       execute_with_blank_lines(consumed_blank_line, additional_blanks)
     end
@@ -194,7 +199,7 @@ class ExecutionDecider
     # Consume all consecutive Dalibo links and blank lines
     loop do
       next_line = peek_next_line(file_enum)
-      
+
       if is_blank_line?(next_line) || is_dalibo_link?(next_line)
         consumed_line = file_enum.next
         consumed_lines << consumed_line
@@ -205,7 +210,7 @@ class ExecutionDecider
   end
 
   def is_dalibo_link?(line)
-    line&.start_with?("**Dalibo Visualization:**")
+    line&.start_with?("[Dalibo]")
   end
 
   def line_matches_pattern?(line, pattern)
@@ -217,9 +222,78 @@ class ExecutionDecider
   end
 
   def should_auto_replace_dalibo_link?
-    # Auto-replace Dalibo links when using explain with result=false
+    # Auto-replace Dalibo links when using explain or flamegraph with result=false
     # This makes sense because with result=false, there's only a Dalibo link,
     # so it should be updated on each run
-    @current_block_explain && !@current_block_result
+    (@current_block_explain || @current_block_flamegraph) && !@current_block_result
+  end
+
+  def is_flamegraph_link?(line)
+    line&.start_with?("![PostgreSQL Query Flamegraph]")
+  end
+
+  def handle_flamegraph_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    # For flamegraph result=false, always replace existing flamegraph links
+    # For flamegraph result=true, follow normal rerun logic
+    if should_auto_replace_flamegraph_link? || @current_block_rerun
+      execute_with_consumed_flamegraph_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    else
+      skip_with_blanks_and_flamegraph(file_enum, consumed_blank_line, additional_blanks)
+    end
+  end
+
+  def handle_immediate_flamegraph_link(file_enum)
+    # For flamegraph result=false, always replace existing flamegraph links
+    # For flamegraph result=true, follow normal rerun logic
+    if should_auto_replace_flamegraph_link? || @current_block_rerun
+      execute_with_consumed_flamegraph(file_enum)
+    else
+      skip_with_existing_flamegraph(file_enum)
+    end
+  end
+
+  def execute_with_consumed_flamegraph(file_enum)
+    consumed_lines = []
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, consume_existing_flamegraph: true }
+  end
+
+  def skip_with_existing_flamegraph(file_enum)
+    consumed_lines = []
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, flamegraph_content: true }
+  end
+
+  def execute_with_consumed_flamegraph_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing_flamegraph: true }
+  end
+
+  def skip_with_blanks_and_flamegraph(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_flamegraph_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, flamegraph_content: true }
+  end
+
+  def consume_flamegraph_links(file_enum, consumed_lines)
+    # Consume all consecutive flamegraph links and blank lines
+    loop do
+      next_line = peek_next_line(file_enum)
+
+      if is_blank_line?(next_line) || is_flamegraph_link?(next_line)
+        consumed_line = file_enum.next
+        consumed_lines << consumed_line
+      else
+        break
+      end
+    end
+  end
+
+  def should_auto_replace_flamegraph_link?
+    # Auto-replace flamegraph links when using flamegraph with result=false
+    # This makes sense because with result=false, there's only a flamegraph link,
+    # so it should be updated on each run
+    @current_block_flamegraph && !@current_block_result
   end
 end

data/lib/flamegraph_helper.rb

@@ -0,0 +1,39 @@
+module FlamegraphHelper
+  private
+
+  FLAMEGRAPH_LINK_PREFIX = "FLAMEGRAPH_LINK:"
+
+  def extract_flamegraph_link(result_output)
+    # Check if the result contains a flamegraph link marker
+    if result_output.start_with?(FLAMEGRAPH_LINK_PREFIX)
+      lines = result_output.split("\n", 2)
+      flamegraph_path = lines[0].sub(FLAMEGRAPH_LINK_PREFIX, "")
+      clean_result = lines[1] || ""
+      flamegraph_link = "![PostgreSQL Query Flamegraph](#{flamegraph_path})"
+      [flamegraph_link, clean_result]
+    else
+      [nil, result_output]
+    end
+  end
+
+  def consume_flamegraph_link_if_present(file_enum, consumed_lines)
+    # Look ahead to see if there are flamegraph links after the result block
+    begin
+      # Keep consuming blank lines and flamegraph links until we hit something else
+      loop do
+        next_line = peek_next_line(file_enum)
+
+        if is_blank_line?(next_line)
+          consumed_lines << file_enum.next
+        elsif next_line&.start_with?("![PostgreSQL Query Flamegraph]")
+          consumed_lines << file_enum.next
+        else
+          # Hit something that's not a blank line or flamegraph link, stop consuming
+          break
+        end
+      end
+    rescue StopIteration
+      # End of file reached, nothing more to consume
+    end
+  end
+end

data/lib/frontmatter_parser.rb

@@ -6,9 +6,11 @@ class FrontmatterParser
 
   def initialize
     @aliases = {}
+    @defaults = {}
+    @language_defaults = {}
   end
 
-  attr_reader :aliases
+  attr_reader :aliases, :defaults, :language_defaults
 
   def parse_frontmatter(file_enum, output_lines)
     first_line = peek_next_line(file_enum)
@@ -22,6 +24,26 @@ class FrontmatterParser
     @aliases[lang] || lang
   end
 
+  def get_default_value(option_name, language, fallback_default)
+    # Priority order:
+    # 1. Language-specific defaults (e.g., psql: { explain: true })
+    # 2. Global defaults (e.g., defaults: { rerun: true })
+    # 3. Fallback default (hardcoded in the application)
+
+    # Check language-specific defaults first
+    if @language_defaults[language] && @language_defaults[language].key?(option_name)
+      return @language_defaults[language][option_name]
+    end
+
+    # Check global defaults
+    if @defaults.key?(option_name)
+      return @defaults[option_name]
+    end
+
+    # Return fallback default
+    fallback_default
+  end
+
   private
 
   def collect_frontmatter_lines(file_enum, output_lines)
@@ -58,14 +80,34 @@ class FrontmatterParser
     markdown_run_config = frontmatter["markdown-run"]
     return unless markdown_run_config.is_a?(Hash)
 
+    # Extract aliases
     aliases = markdown_run_config["alias"]
-    return unless aliases.is_a?(Array)
+    if aliases.is_a?(Array)
+      aliases.each do |alias_config|
+        next unless alias_config.is_a?(Hash)
+
+        alias_config.each do |alias_name, target_lang|
+          @aliases[alias_name.to_s] = target_lang.to_s
+        end
+      end
+    end
+
+    # Extract defaults
+    defaults = markdown_run_config["defaults"]
+    if defaults.is_a?(Hash)
+      defaults.each do |option_name, option_value|
+        @defaults[option_name.to_s] = option_value
+      end
+    end
 
-    aliases.each do |alias_config|
-      next unless alias_config.is_a?(Hash)
+    # Extract language-specific defaults
+    markdown_run_config.each do |key, value|
+      next if ["alias", "defaults"].include?(key)
+      next unless value.is_a?(Hash)
 
-      alias_config.each do |alias_name, target_lang|
-        @aliases[alias_name.to_s] = target_lang.to_s
+      @language_defaults[key.to_s] = {}
+      value.each do |option_name, option_value|
+        @language_defaults[key.to_s][option_name.to_s] = option_value
       end
     end
   end

data/lib/language_configs.rb

@@ -1,7 +1,7 @@
 require 'securerandom'
 
 JS_CONFIG = {
-  command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+  command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
     # Check if bun is available
     bun_exists = system("command -v bun > /dev/null 2>&1")
     if bun_exists
@@ -16,20 +16,20 @@ JS_CONFIG = {
 }.freeze
 
 SQLITE_CONFIG = {
-  command: ->(code_content, temp_file_path, input_file_path = nil, explain = false) { [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
+  command: ->(code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) { [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
   temp_file_suffix: ".db" # Temp file is the database
 }.freeze
 
 SUPPORTED_LANGUAGES = {
   "psql" => {
-    command: ->(code_content, _temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(code_content, _temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       psql_exists = system("command -v psql > /dev/null 2>&1")
       unless psql_exists
         abort "Error: psql command not found. Please install PostgreSQL or ensure psql is in your PATH."
       end
 
-      # Modify the SQL query if explain option is enabled
-      if explain
+      # Modify the SQL query if explain or flamegraph option is enabled
+      if explain || flamegraph
         # Wrap the query with EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
         # Remove any trailing semicolons and whitespace, then add our EXPLAIN wrapper
         clean_query = code_content.strip.gsub(/;\s*$/, '')
@@ -41,7 +41,7 @@ SUPPORTED_LANGUAGES = {
     }
   },
   "ruby" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       xmpfilter_exists = system("command -v xmpfilter > /dev/null 2>&1")
       unless xmpfilter_exists
         abort "Error: xmpfilter command not found. Please install xmpfilter or ensure it is in your PATH."
@@ -57,7 +57,7 @@ SUPPORTED_LANGUAGES = {
   "sqlite" => SQLITE_CONFIG,
   "sqlite3" => SQLITE_CONFIG, # Alias for sqlite
   "bash" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       bash_exists = system("command -v bash > /dev/null 2>&1")
       unless bash_exists
         abort "Error: bash command not found. Please ensure bash is in your PATH."
@@ -67,7 +67,7 @@ SUPPORTED_LANGUAGES = {
     temp_file_suffix: ".sh"
   },
   "zsh" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       zsh_exists = system("command -v zsh > /dev/null 2>&1")
       unless zsh_exists
         abort "Error: zsh command not found. Please ensure zsh is in your PATH."
@@ -77,7 +77,7 @@ SUPPORTED_LANGUAGES = {
     temp_file_suffix: ".zsh"
   },
   "sh" => {
-    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       sh_exists = system("command -v sh > /dev/null 2>&1")
       unless sh_exists
         abort "Error: sh command not found. Please ensure sh is in your PATH."
@@ -87,7 +87,7 @@ SUPPORTED_LANGUAGES = {
     temp_file_suffix: ".sh"
   },
   "mermaid" => {
-    command: ->(code_content, temp_file_path, input_file_path = nil, explain = false) {
+    command: ->(code_content, temp_file_path, input_file_path = nil, explain = false, flamegraph = false) {
       mmdc_exists = system("command -v mmdc > /dev/null 2>&1")
       unless mmdc_exists
         abort "Error: mmdc command not found. Please install @mermaid-js/mermaid-cli: npm install -g @mermaid-js/mermaid-cli"

data/lib/markdown/run/version.rb

@@ -2,6 +2,6 @@
 
 module Markdown
   module Run
-    VERSION = "0.1.10"
+    VERSION = "0.1.12"
   end
 end

data/lib/markdown_processor.rb

@@ -4,20 +4,22 @@ require_relative "code_block_parser"
 require_relative "code_executor"
 require_relative "execution_decider"
 require_relative "enum_helper"
+require_relative "dalibo_helper"
+require_relative "code_block_helper"
+require_relative "result_helper"
 
 class MarkdownProcessor
   include EnumHelper
+  include DaliboHelper
+  include CodeBlockHelper
+  include ResultHelper
+
   def initialize(temp_dir, input_file_path = nil)
     @temp_dir = temp_dir
     @input_file_path = input_file_path
     @output_lines = []
-    @state = :outside_code_block
-    @current_block_lang = ""
-    @current_code_content = ""
-    @current_block_rerun = false
-    @current_block_run = true
-    @current_block_explain = false
-    @current_block_result = true
+    reset_code_block_state
+
     @frontmatter_parser = FrontmatterParser.new
     @code_block_parser = CodeBlockParser.new(@frontmatter_parser)
   end
@@ -40,31 +42,6 @@ class MarkdownProcessor
     @frontmatter_parser.resolve_language(lang)
   end
 
-  def ruby_style_result?(lang)
-    lang_config = SUPPORTED_LANGUAGES[lang]
-    lang_config && lang_config[:result_block_type] == "ruby"
-  end
-
-  def mermaid_style_result?(lang)
-    lang_config = SUPPORTED_LANGUAGES[lang]
-    lang_config && lang_config[:result_handling] == :mermaid_svg
-  end
-
-  def result_block_header(lang)
-    ruby_style_result?(lang) ? "```ruby RESULT\n" : "```RESULT\n"
-  end
-
-  def result_block_regex(lang)
-    if mermaid_style_result?(lang)
-      # For mermaid, look for existing image tags with .svg extension
-      /^!\[.*\]\(.*\.svg\)$/i
-    elsif ruby_style_result?(lang)
-      /^```ruby\s+RESULT$/i
-    else
-      /^```RESULT$/i
-    end
-  end
-
   def is_block_end?(line)
     @code_block_parser.is_block_end?(line)
   end
@@ -73,22 +50,6 @@ class MarkdownProcessor
     !content.strip.empty?
   end
 
-  def add_result_block(result_output, blank_line_before_new_result)
-    if mermaid_style_result?(@current_block_lang)
-      # For mermaid, add the image tag directly without a result block
-      @output_lines << "\n" if blank_line_before_new_result.nil?
-      @output_lines << result_output
-      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-      @output_lines << "\n"
-    else
-      @output_lines << "\n" if blank_line_before_new_result.nil?
-      @output_lines << result_block_header(@current_block_lang)
-      @output_lines << result_output
-      @output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-      @output_lines << "```\n\n"
-    end
-  end
-
   def line_matches_pattern?(line, pattern)
     line && line.match?(pattern)
   end
@@ -97,22 +58,6 @@ class MarkdownProcessor
     line && line.strip == ""
   end
 
-  def parse_rerun_option(options_string)
-    @code_block_parser.parse_rerun_option(options_string)
-  end
-
-  def parse_run_option(options_string)
-    @code_block_parser.parse_run_option(options_string)
-  end
-
-  def parse_explain_option(options_string)
-    @code_block_parser.parse_explain_option(options_string)
-  end
-
-  def parse_result_option(options_string)
-    @code_block_parser.parse_result_option(options_string)
-  end
-
   def handle_line(current_line, file_enum)
     case @state
     when :outside_code_block
@@ -144,199 +89,4 @@ class MarkdownProcessor
       accumulate_code_content(current_line)
     end
   end
-
-  def handle_inside_result_block(current_line, file_enum)
-    @output_lines << current_line
-    if is_block_end?(current_line)
-      @state = :outside_code_block
-    end
-  end
-
-  def handle_existing_ruby_result_block(current_line, file_enum)
-    warn "Found existing '```ruby RESULT' block, passing through."
-    @output_lines << current_line
-    @state = :inside_result_block
-  end
-
-  def start_code_block(current_line, lang, options_string = nil)
-    @output_lines << current_line
-    @current_block_lang = resolve_language(lang)
-    @current_block_rerun = parse_rerun_option(options_string)
-    @current_block_run = parse_run_option(options_string)
-    @current_block_explain = parse_explain_option(options_string)
-    @current_block_result = parse_result_option(options_string)
-    @state = :inside_code_block
-    @current_code_content = ""
-  end
-
-  def accumulate_code_content(current_line)
-    @current_code_content += current_line
-    @output_lines << current_line
-  end
-
-  def end_code_block(current_line, file_enum)
-    @output_lines << current_line
-
-    decision = decide_execution(file_enum)
-
-    if decision[:execute]
-      # If we consumed lines for rerun, don't add them to output (they'll be replaced)
-      execute_and_add_result(decision[:blank_line])
-    else
-      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum, decision)
-    end
-
-    reset_code_block_state
-  end
-
-  def decide_execution(file_enum)
-    decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang, @current_block_explain, @current_block_result)
-    decision = decider.decide(file_enum, method(:result_block_regex))
-
-    # Handle the consume_existing flag for rerun scenarios
-    if decision[:consume_existing]
-      consume_existing_result_block(file_enum, decision[:consumed_lines])
-    elsif decision[:consume_existing_dalibo]
-      # Dalibo links are already consumed in the decision process
-      # Just acknowledge they were consumed
-    end
-
-    decision
-  end
-
-  def execute_and_add_result(blank_line_before_new_result)
-    @output_lines << blank_line_before_new_result if blank_line_before_new_result
-
-    if has_content?(@current_code_content)
-      result_output = CodeExecutor.execute(@current_code_content, @current_block_lang, @temp_dir, @input_file_path, @current_block_explain)
-
-      # Check if result contains a Dalibo link for psql explain queries
-      dalibo_link, clean_result = extract_dalibo_link(result_output)
-
-      # Add the result block only if result=true (default)
-      if @current_block_result
-        add_result_block(clean_result || result_output, blank_line_before_new_result)
-      end
-
-      # Always add Dalibo link if it exists, even when result=false
-      if dalibo_link
-        # Add appropriate spacing based on whether result block was shown
-        if @current_block_result
-          @output_lines << "#{dalibo_link}\n\n"
-        else
-          @output_lines << "\n#{dalibo_link}\n\n"
-        end
-      end
-    else
-      warn "Skipping empty code block for language '#{@current_block_lang}'."
-    end
-  end
-
-  def skip_and_pass_through_result(lines_to_pass_through, file_enum, decision = nil)
-    # Handle run=false case where there are no lines to pass through
-    if lines_to_pass_through.empty?
-      warn "Skipping execution due to run=false option."
-      return
-    end
-
-    # Check if this is Dalibo content
-    if decision && decision[:dalibo_content]
-      warn "Found existing Dalibo link for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      # No additional consumption needed for Dalibo links
-      return
-    end
-
-    if mermaid_style_result?(@current_block_lang)
-      warn "Found existing mermaid SVG image for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      # For mermaid, no additional consumption needed since it's just an image line
-    else
-      lang_specific_result_type = ruby_style_result?(@current_block_lang) ? "```ruby RESULT" : "```RESULT"
-      warn "Found existing '#{lang_specific_result_type}' block for current #{@current_block_lang} block, skipping execution."
-      @output_lines.concat(lines_to_pass_through)
-      consume_result_block_content(file_enum)
-    end
-  end
-
-  def consume_result_block_content(file_enum)
-    consume_block_lines(file_enum) do |line|
-      @output_lines << line
-    end
-  end
-
-  def consume_existing_result_block(file_enum, consumed_lines)
-    if mermaid_style_result?(@current_block_lang)
-      # For mermaid, there's no result block to consume, just the image line
-      # The image line should already be in consumed_lines from ExecutionDecider
-      return
-    end
-
-    consume_block_lines(file_enum) do |line|
-      consumed_lines << line
-    end
-
-    # After consuming the result block, check if there's a Dalibo link to consume as well
-    consume_dalibo_link_if_present(file_enum, consumed_lines)
-  end
-
-  def consume_block_lines(file_enum)
-    begin
-      loop do
-        result_block_line = file_enum.next
-        yield result_block_line
-        break if is_block_end?(result_block_line)
-      end
-    rescue StopIteration
-      warn "Warning: End of file reached while consuming result block."
-    end
-  end
-
-  def reset_code_block_state
-    @state = :outside_code_block
-    @current_code_content = ""
-    @current_block_rerun = false
-    @current_block_run = true
-    @current_block_explain = false
-    @current_block_result = true
-  end
-
-  def stderr_has_content?(stderr_output)
-    stderr_output && !stderr_output.strip.empty?
-  end
-
-  def extract_dalibo_link(result_output)
-    # Check if the result contains a Dalibo link marker
-    if result_output.start_with?("DALIBO_LINK:")
-      lines = result_output.split("\n", 2)
-      dalibo_url = lines[0].sub("DALIBO_LINK:", "")
-      clean_result = lines[1] || ""
-      dalibo_link = "**Dalibo Visualization:** [View Query Plan](#{dalibo_url})"
-      [dalibo_link, clean_result]
-    else
-      [nil, result_output]
-    end
-  end
-
-  def consume_dalibo_link_if_present(file_enum, consumed_lines)
-    # Look ahead to see if there are Dalibo links after the result block
-    begin
-      # Keep consuming blank lines and Dalibo links until we hit something else
-      loop do
-        next_line = peek_next_line(file_enum)
-
-        if is_blank_line?(next_line)
-          consumed_lines << file_enum.next
-        elsif next_line&.start_with?("**Dalibo Visualization:**")
-          consumed_lines << file_enum.next
-        else
-          # Hit something that's not a blank line or Dalibo link, stop consuming
-          break
-        end
-      end
-    rescue StopIteration
-      # End of file reached, nothing more to consume
-    end
-  end
-
 end