markdown-run 0.1.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e078472cf91253d16b3341865954ead4ce1d6539d509c5ed6d54302c5a3147d
-  data.tar.gz: 76f40572409ed01a1797c4902896b783d3a0403783031fca8c8dff04a1499acf
+  metadata.gz: 72c9c060b9169413ee686c9a4958b36b11d5271a4222d598bfe0c847364488e0
+  data.tar.gz: 56bfea5eb072bfbf7db692a6df64c08e901f7a77551f2b17491a4a84201220fb
 SHA512:
-  metadata.gz: ea3ecacb94cbe3e52dacb9fdb4ea447790990cee631fd890f5389d483157d7e16621eda6dba68dddf13d1e1f5f499b8bc2ac3952e2ca1752f133f5aa496403b1
-  data.tar.gz: 8ae64565dc336f5158a877c54a02520bc6a0e6923c6bbdd705c2cff8c848ff832f0a0683f30c2e86df883a356d89e60269cebb219d9a9732212fc5edfd27fea6
+  metadata.gz: f4b2c6aa7b3fec529749f56e4a64c186060097b94f64678c96742759d51f4b7dbb1d2014c98abb4ff047f8ba62ef15d1f32612e2b19cbdafa480664f3556a420
+  data.tar.gz: a7bb6b114beaea5f0857534cee766f9dcb157ab39949f433a5965acb558996f30a3fcbd6a13a3df3a264ddf64b1115dab089af7b674b68195467b7a2e482ef5f

data/.tool-versions

@@ -1 +1 @@
-ruby 3.3.5
+ruby 3.4.6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.1.12] - 2025-06-04
+
+-   Added `flamegraph` option for psql code blocks to generate PostgreSQL query execution plan flamegraphs as SVG images
+-   PostgreSQL flamegraphs provide interactive, color-coded visualization of query performance with hover tooltips
+-   Flamegraph SVG files follow same directory structure as mermaid diagrams (organized by markdown file basename)
+-   Added flamegraph option support to frontmatter defaults and language-specific configurations
+
 ## [0.1.11] - 2025-06-04
 
 -   options are customizable with the yaml frontmatter

data/README.md

@@ -55,10 +55,21 @@ example vscode keybinding
 
 ### Code block options
 
+Options are specified using Pandoc-style curly braces after the language identifier:
+
+```markdown
+```ruby {rerun=true}
+puts "Hello World"
+```
+```
+
+**Available options:**
+
 - `run=true` or `run=false` to control whether a code block should be executed at all. `run=true` is the default if not specified
 - `rerun=true` or `rerun=false` to control whether a code block should be re-executed if a result block already exists. `rerun=false` is the default if not specified
 - `result=true` or `result=false` to control whether the result block should be displayed after execution. `result=true` is the default if not specified. When `result=false`, the code still executes but the result block is hidden
 - `explain=true` or `explain=false` for psql code blocks to generate query execution plans with Dalibo visualization links. `explain=false` is the default if not specified
+- `flamegraph=true` or `flamegraph=false` for psql code blocks to generate PostgreSQL query execution plan flamegraphs as SVG images. `flamegraph=false` is the default if not specified
 
 Options can be combined. If `run=false` is specified, the code block will not execute regardless of the `rerun` setting. The `result` option only affects display of the result block, not code execution.
 
@@ -70,40 +81,87 @@ Options can also be specified using standalone syntax without explicit `=true`:
 - `rerun` is equivalent to `rerun=true`
 - `result` is equivalent to `result=true`
 - `explain` is equivalent to `explain=true`
+- `flamegraph` is equivalent to `flamegraph=true`
 
 Explicit assignments (e.g., `run=false`) take precedence over standalone options.
 
 Examples:
 
-```js run=false
+```js {run=false}
 console.log("This will not execute at all");
 ```
 
-```js rerun
+```js {rerun}
 console.log("This will re-execute even if result exists");
 ```
 
-```js run=true rerun=false
+```js {run=true rerun=false}
 console.log("This will execute only if no result exists");
 ```
 
-```ruby result=false run
+```ruby {result=false run}
 puts "This executes but the result block is hidden"
 ```
 
-```psql explain
+```psql {explain}
 SELECT * FROM users WHERE id = 1;
 ```
 
-```psql explain=true
+```psql {explain=true}
 EXPLAIN (ANALYZE) SELECT * FROM large_table;
 ```
 
-```psql result=false explain
+```psql {flamegraph}
+SELECT u.name, COUNT(o.id) as order_count
+FROM users u
+LEFT JOIN orders o ON u.id = o.user_id
+WHERE u.created_at > '2024-01-01'
+GROUP BY u.id, u.name
+ORDER BY order_count DESC
+LIMIT 10;
+```
+
+```psql {flamegraph=true result=false}
+-- This will generate a flamegraph but hide the JSON result block
+SELECT * FROM complex_query_with_joins;
+```
+
+```psql {result=false explain}
 SELECT * FROM large_table;
 -- This will execute the explain query and show the Dalibo link but hide the result block
 ```
 
+### PostgreSQL Flamegraphs
+
+PostgreSQL flamegraph blocks generate interactive SVG flamegraphs from query execution plans:
+
+```psql {flamegraph}
+SELECT users.*, orders.total
+FROM users
+JOIN orders ON users.id = orders.user_id
+WHERE users.created_at > '2024-01-01';
+```
+
+This generates:
+
+- An SVG flamegraph file in a directory named after the markdown file
+- Filename format: `my-document-flamegraph-20250118-143022-a1b2c3.svg`
+- Embedded image tag: `![PostgreSQL Query Flamegraph](my-document/my-document-flamegraph-20250118-143022-a1b2c3.svg)`
+
+**Flamegraph features:**
+
+- **Interactive**: Hover over rectangles to see detailed timing information
+- **Color-coded**: Different colors for operation types (red=seq scans, green=index scans, blue=joins, etc.)
+- **Hierarchical**: Shows query plan structure visually
+- **Performance insights**: Width represents execution time, making bottlenecks immediately visible
+
+**What flamegraphs help identify:**
+
+- Slow operations (widest rectangles)
+- Query plan structure (nested relationships)
+- Inefficient operations (color-coded by type)
+- Execution time distribution across plan nodes
+
 ### Mermaid diagrams
 
 Mermaid blocks generate SVG files and insert markdown image tags:
@@ -163,6 +221,7 @@ markdown-run:
 - `rerun`: Control whether to re-execute if result exists (default: `false`)
 - `result`: Control whether to show result blocks (default: `true`)
 - `explain`: For psql blocks, generate explain plans (default: `false`)
+- `flamegraph`: For psql blocks, generate flamegraph SVGs (default: `false`)
 
 **Examples:**
 
@@ -184,6 +243,14 @@ markdown-run:
     explain: true
 ```
 
+Enable flamegraphs by default for all psql blocks:
+
+```yaml
+markdown-run:
+  psql:
+    flamegraph: true
+```
+
 Language-specific settings override global defaults:
 
 ```yaml

data/Rakefile

@@ -1,3 +1,4 @@
+require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
@@ -19,4 +20,67 @@ task :flog_detailed do
   system("flog -d lib/ exe/ test/")
 end
 
+desc "Run tests with detailed timing information"
+task :test_profile do
+  require 'benchmark'
+  
+  puts "Running tests with detailed profiling..."
+  
+  # Run tests with verbose output and capture timing
+  output = `bundle exec rake test TESTOPTS="-v" 2>&1`
+  
+  # Extract test timings
+  timings = []
+  output.scan(/^(.+) = ([0-9]+\.[0-9]+) s = \.$/) do |test_name, time|
+    timings << [test_name, time.to_f]
+  end
+  
+  # Sort by time (descending)
+  timings.sort_by! { |_, time| -time }
+  
+  puts "\n" + "="*80
+  puts "TOP 15 SLOWEST TESTS"
+  puts "="*80
+  
+  timings.first(15).each_with_index do |(test_name, time), index|
+    test_display = test_name.length > 60 ? test_name[0...60] + "..." : test_name
+    printf "%2d. %-63s %6.2f s\n", index + 1, test_display, time
+  end
+  
+  puts "\n" + "="*80
+  puts "SUMMARY"
+  puts "="*80
+  total_time = timings.sum { |_, time| time }
+  slow_tests = timings.select { |_, time| time > 0.1 }
+  
+  puts "Total test time: #{total_time.round(2)} seconds"
+  puts "Tests slower than 0.1s: #{slow_tests.count}"
+  puts "Time spent in slow tests: #{slow_tests.sum { |_, time| time }.round(2)} seconds (#{((slow_tests.sum { |_, time| time } / total_time) * 100).round(1)}%)"
+end
+
+desc "Release"
+task :release do
+  `gem bump`
+  `bundle`
+  `git commit --amend`
+  `git push`
+  `git push --tags`
+  `gem release`
+end
+
+# Coverage task
+desc "Run tests with SimpleCov coverage report"
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task[:test].invoke
+
+  puts "\n🎯 Coverage Report Generated!"
+  puts "📊 Open coverage/index.html to view detailed coverage report"
+
+  # Try to open coverage report automatically (works on macOS)
+  if RUBY_PLATFORM.include?('darwin')
+    system('open coverage/index.html')
+  end
+end
+
 task default: :test

data/lib/code_block_helper.rb

@@ -10,16 +10,18 @@ module CodeBlockHelper
     @current_block_rerun = false
     @current_block_run = true
     @current_block_explain = false
+    @current_block_flamegraph = false
     @current_block_result = true
   end
 
 
   def start_code_block(current_line, lang, options_string = nil)
     @output_lines << current_line
-    @current_block_lang = resolve_language(lang)
+    @current_block_lang = @language_resolver.resolve_language(lang)
     @current_block_rerun = @code_block_parser.parse_rerun_option(options_string, @current_block_lang)
     @current_block_run = @code_block_parser.parse_run_option(options_string, @current_block_lang)
     @current_block_explain = @code_block_parser.parse_explain_option(options_string, @current_block_lang)
+    @current_block_flamegraph = @code_block_parser.parse_flamegraph_option(options_string, @current_block_lang)
     @current_block_result = @code_block_parser.parse_result_option(options_string, @current_block_lang)
     @state = :inside_code_block
     @current_code_content = ""
@@ -27,27 +29,33 @@ module CodeBlockHelper
 
   def accumulate_code_content(current_line)
     @current_code_content += current_line
-    @output_lines << current_line
+    # For ruby blocks, don't output code content yet - we'll replace it with xmpfilter output
+    unless ruby_style_result?(@current_block_lang)
+      @output_lines << current_line
+    end
   end
 
   def end_code_block(current_line, file_enum)
-    @output_lines << current_line
+    # For ruby blocks, don't output closing ``` yet - we'll add it after the xmpfilter output
+    unless ruby_style_result?(@current_block_lang)
+      @output_lines << current_line
+    end
 
     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])
+      execute_and_add_result(decision[:blank_line], current_line)
     else
-      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum, decision)
+      skip_and_pass_through_result(decision[:lines_to_pass_through], file_enum, decision, current_line)
     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))
+    decider = ExecutionDecider.new(@current_block_run, @current_block_rerun, @current_block_lang, @current_block_explain, @current_block_flamegraph, @current_block_result)
+    decision = decider.decide(file_enum, method(:result_block_regex), @current_code_content)
 
     # Handle the consume_existing flag for rerun scenarios
     if decision[:consume_existing]

data/lib/code_block_parser.rb

@@ -1,13 +1,15 @@
 require_relative "language_configs"
 
 class CodeBlockParser
-  # Code block header pattern: ```language options
-  CODE_BLOCK_START_PATTERN = /^```(\w+)(?:\s+(.*))?$/i
+  # Code block header pattern: ```language {options}
+  # Supports both ```language and ```language {options} formats
+  CODE_BLOCK_START_PATTERN = /^```(\w+)(?:\s*\{(.*)\})?$/i
   RUBY_RESULT_BLOCK_PATTERN = /^```ruby\s+RESULT$/i
   BLOCK_END_PATTERN = "```"
 
-  def initialize(frontmatter_parser)
+  def initialize(frontmatter_parser, language_resolver)
     @frontmatter_parser = frontmatter_parser
+    @language_resolver = language_resolver
   end
 
   def parse_code_block_header(line)
@@ -49,6 +51,11 @@ class CodeBlockParser
     parse_boolean_option(options_string, "explain", default_value)
   end
 
+  def parse_flamegraph_option(options_string, language = nil)
+    default_value = @frontmatter_parser.get_default_value("flamegraph", language, false)
+    parse_boolean_option(options_string, "flamegraph", default_value)
+  end
+
   def parse_result_option(options_string, language = nil)
     default_value = @frontmatter_parser.get_default_value("result", language, true)
     parse_boolean_option(options_string, "result", default_value)
@@ -57,7 +64,7 @@ class CodeBlockParser
   private
 
   def resolve_language(lang)
-    @frontmatter_parser.resolve_language(lang)
+    @language_resolver.resolve_language(lang)
   end
 
   def parse_boolean_option(options_string, option_name, default_value)

data/lib/code_executor.rb

@@ -1,54 +1,59 @@
 require "tempfile"
 require "open3"
 require_relative "language_configs"
+require_relative "test_silencer"
 
 class CodeExecutor
-  def self.execute(code_content, lang, temp_dir, input_file_path = nil, explain = false)
-    new.execute(code_content, lang, temp_dir, input_file_path, explain)
+  def self.execute(code_content, lang, temp_dir, input_file_path = nil, explain = false, flamegraph = false)
+    new.execute(code_content, lang, temp_dir, input_file_path, explain, flamegraph)
   end
 
-  def execute(code_content, lang, temp_dir, input_file_path = nil, explain = false)
+  def execute(code_content, lang, temp_dir, input_file_path = nil, explain = false, flamegraph = false)
     lang_key = lang.downcase
     lang_config = SUPPORTED_LANGUAGES[lang_key]
 
     return handle_unsupported_language(lang) unless lang_config
 
-    warn "Executing #{lang_key} code block..."
+    TestSilencer.warn_unless_testing("Executing #{lang_key} code block...")
 
-    result = execute_with_config(code_content, lang_config, temp_dir, lang_key, input_file_path, explain)
-    process_execution_result(result, lang_config, lang_key, explain)
+    result = execute_with_config(code_content, lang_config, temp_dir, lang_key, input_file_path, explain, flamegraph)
+    process_execution_result(result, lang_config, lang_key, explain, flamegraph)
   end
 
   private
 
-
-
   def stderr_has_content?(stderr_output)
     stderr_output && !stderr_output.strip.empty?
   end
 
   def handle_unsupported_language(lang)
-    warn "Unsupported language: #{lang}"
+    TestSilencer.warn_unless_testing "Unsupported language: #{lang}"
     "ERROR: Unsupported language: #{lang}"
   end
 
-  def execute_with_config(code_content, lang_config, temp_dir, lang_key, input_file_path = nil, explain = false)
+  def execute_with_config(code_content, lang_config, temp_dir, lang_key, input_file_path = nil, explain = false, flamegraph = false)
     cmd_lambda = lang_config[:command]
     temp_file_suffix = lang_config[:temp_file_suffix]
 
     if temp_file_suffix
-      execute_with_temp_file(code_content, cmd_lambda, temp_file_suffix, temp_dir, lang_key, input_file_path, explain)
+      execute_with_temp_file(code_content, cmd_lambda, temp_file_suffix, temp_dir, lang_key, input_file_path, explain, flamegraph)
     else
-      execute_direct_command(code_content, cmd_lambda, explain)
+      execute_direct_command(code_content, cmd_lambda, input_file_path, explain, flamegraph)
     end
   end
 
-  def execute_with_temp_file(code_content, cmd_lambda, temp_file_suffix, temp_dir, lang_key, input_file_path = nil, explain = false)
+  def execute_with_temp_file(code_content, cmd_lambda, temp_file_suffix, temp_dir, lang_key, input_file_path = nil, explain = false, flamegraph = false)
     result = nil
     Tempfile.create([lang_key, temp_file_suffix], temp_dir) do |temp_file|
       temp_file.write(code_content)
       temp_file.close
-      command_to_run, exec_options = cmd_lambda.call(code_content, temp_file.path, input_file_path, explain)
+      command_to_run, exec_options = cmd_lambda.call(**{
+        code_content: code_content,
+        temp_file_path: temp_file.path,
+        input_file_path: input_file_path,
+        explain: explain,
+        flamegraph: flamegraph
+      })
 
       # Extract output_path if present (for mermaid)
       output_path = exec_options.delete(:output_path) if exec_options.is_a?(Hash)
@@ -58,27 +63,41 @@ class CodeExecutor
         stdout: captured_stdout,
         stderr: captured_stderr,
         status: captured_status_obj,
-        output_path: output_path # For mermaid SVG output
+        output_path: output_path, # For mermaid SVG output
+        input_file_path: input_file_path # Pass through for flamegraph generation
       }
     end
     result
   end
 
-  def execute_direct_command(code_content, cmd_lambda, explain = false)
-    command_to_run, exec_options = cmd_lambda.call(code_content, nil, nil, explain)
+  def execute_direct_command(code_content, cmd_lambda, input_file_path = nil, explain = false, flamegraph = false)
+    command_to_run, exec_options = cmd_lambda.call(**{
+      code_content: code_content,
+      temp_file_path: nil,
+      input_file_path: input_file_path,
+      explain: explain,
+      flamegraph: flamegraph
+    })
     captured_stdout, captured_stderr, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
-    { stdout: captured_stdout, stderr: captured_stderr, status: captured_status_obj }
+    { stdout: captured_stdout, stderr: captured_stderr, status: captured_status_obj, input_file_path: input_file_path }
   end
 
-  def process_execution_result(result, lang_config, lang_key, explain = false)
+  def process_execution_result(result, lang_config, lang_key, explain = false, flamegraph = false)
     exit_status, result_output, stderr_output = format_captured_output(result, lang_config)
 
     if exit_status != 0
       result_output = add_error_to_output(exit_status, lang_config, lang_key, result_output, stderr_output)
     elsif lang_config && lang_config[:result_handling] == :mermaid_svg
       result_output = handle_mermaid_svg_result(result, lang_key)
-    elsif explain && lang_key == "psql"
-      result_output = handle_psql_explain_result(result_output)
+    else
+      # Handle psql explain and flamegraph processing (both can be enabled)
+      if explain && lang_key == "psql"
+        result_output = handle_psql_explain_result(result_output)
+      end
+
+      if flamegraph && lang_key == "psql"
+        result_output = handle_psql_flamegraph_result(result_output, result[:input_file_path])
+      end
     end
 
     result_output
@@ -98,8 +117,8 @@ class CodeExecutor
   end
 
   def add_error_to_output(exit_status, lang_config, lang_key, result_output, stderr_output)
-    warn "Code execution failed for language '#{lang_key}' with status #{exit_status}."
-    warn "Stderr:\n#{stderr_output}" if stderr_has_content?(stderr_output)
+    TestSilencer.warn_unless_testing "Code execution failed for language '#{lang_key}' with status #{exit_status}."
+    TestSilencer.warn_unless_testing "Stderr:\n#{stderr_output}" if stderr_has_content?(stderr_output)
 
     is_js_error_already_formatted = lang_config && lang_config[:error_handling] == :js_specific && result_output.include?("Stderr:")
     unless result_output.downcase.include?("error:") || is_js_error_already_formatted
@@ -110,15 +129,11 @@ class CodeExecutor
     result_output
   end
 
-  def stderr_has_content?(stderr_output)
-    stderr_output && !stderr_output.strip.empty?
-  end
-
   def handle_mermaid_svg_result(result, lang_key)
     output_path = result[:output_path]
 
     unless output_path && File.exist?(output_path)
-      warn "Warning: Mermaid SVG file not generated at expected path: #{output_path}"
+      TestSilencer.warn_unless_testing "Warning: Mermaid SVG file not generated at expected path: #{output_path}"
       return "Error: SVG file not generated"
     end
 
@@ -137,7 +152,7 @@ class CodeExecutor
       relative_path = svg_filename
     end
 
-    warn "Generated Mermaid SVG: #{relative_path}"
+    TestSilencer.warn_unless_testing("Generated Mermaid SVG: #{relative_path}")
 
     # Return markdown image tag instead of typical result content
     "![Mermaid Diagram](#{relative_path})"
@@ -169,6 +184,78 @@ class CodeExecutor
     end
   end
 
+  def handle_psql_flamegraph_result(result_output, input_file_path = nil)
+    require_relative 'pg_flamegraph_svg'
+
+    begin
+      # Extract clean JSON from result_output (might contain Dalibo link prefix)
+      json_text = if result_output.start_with?("DALIBO_LINK:")
+        # Extract the JSON part after the Dalibo link line
+        lines = result_output.split("\n", 2)
+        lines[1] || ""
+      else
+        result_output.strip
+      end
+
+      # Parse the EXPLAIN JSON output
+      json_data = JSON.parse(json_text)
+
+      # Generate SVG flamegraph
+      flamegraph_generator = PostgreSQLFlameGraphSVG.new(JSON.generate(json_data))
+      svg_content = flamegraph_generator.generate_svg
+
+      # Save SVG file following same pattern as mermaid
+      if input_file_path
+        # Extract markdown file basename without extension
+        md_basename = File.basename(input_file_path, ".*")
+
+        # Create directory named after the markdown file
+        output_dir = File.join(File.dirname(input_file_path), md_basename)
+        Dir.mkdir(output_dir) unless Dir.exist?(output_dir)
+
+        # Generate unique filename with markdown basename prefix
+        timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+        random_suffix = SecureRandom.hex(6)
+        svg_filename = "#{md_basename}-flamegraph-#{timestamp}-#{random_suffix}.svg"
+        output_path = File.join(output_dir, svg_filename)
+      else
+        # Fallback to simple naming
+        timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+        output_path = "pg-flamegraph-#{timestamp}.svg"
+      end
+
+      # Write SVG file
+      File.write(output_path, svg_content)
+
+      # Generate relative path for markdown
+      if input_file_path
+        relative_path = "#{File.basename(output_dir)}/#{File.basename(output_path)}"
+      else
+        relative_path = File.basename(output_path)
+      end
+
+      TestSilencer.warn_unless_testing("Generated PostgreSQL flamegraph: #{relative_path}")
+
+      # Return a special format that the markdown processor can parse
+      # Preserve any existing Dalibo link prefix
+      if result_output.start_with?("DALIBO_LINK:")
+        lines = result_output.split("\n", 2)
+        dalibo_part = lines[0]
+        json_part = lines[1] || ""
+        "#{dalibo_part}\nFLAMEGRAPH_LINK:#{relative_path}\n#{json_part}"
+      else
+        "FLAMEGRAPH_LINK:#{relative_path}\n#{json_text}"
+      end
+
+    rescue JSON::ParserError => e
+      TestSilencer.warn_unless_testing "Error parsing EXPLAIN JSON: #{e.message}"
+      result_output
+    rescue => e
+      TestSilencer.warn_unless_testing "Error generating flamegraph: #{e.message}"
+      result_output
+    end
+  end
+
   private
 
   def submit_plan_to_dalibo(plan_json)
@@ -201,11 +288,11 @@ class CodeExecutor
           nil
         end
       else
-        warn "Failed to submit plan to Dalibo: #{response.code} #{response.message}"
+        TestSilencer.warn_unless_testing "Failed to submit plan to Dalibo: #{response.code} #{response.message}"
         nil
       end
     rescue => e
-      warn "Error submitting plan to Dalibo: #{e.message}"
+      TestSilencer.warn_unless_testing "Error submitting plan to Dalibo: #{e.message}"
       nil
     end
   end

data/lib/dalibo_helper.rb

@@ -9,7 +9,7 @@ module DaliboHelper
       lines = result_output.split("\n", 2)
       dalibo_url = lines[0].sub(DALIBO_LINK_PREFIX, "")
       clean_result = lines[1] || ""
-      dalibo_link = "**Dalibo Visualization:** [View Query Plan](#{dalibo_url})"
+      dalibo_link = "[Dalibo](#{dalibo_url})"
       [dalibo_link, clean_result]
     else
       [nil, result_output]
@@ -25,7 +25,7 @@ module DaliboHelper
 
         if is_blank_line?(next_line)
           consumed_lines << file_enum.next
-        elsif next_line&.start_with?("**Dalibo Visualization:**")
+        elsif next_line&.start_with?("[Dalibo]")
           consumed_lines << file_enum.next
         else
           # Hit something that's not a blank line or Dalibo link, stop consuming