markdown-run 0.1.8 → 0.1.10

data/lib/code_executor.rb

@@ -0,0 +1,212 @@
+require "tempfile"
+require "open3"
+require_relative "language_configs"
+
+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)
+  end
+
+  def execute(code_content, lang, temp_dir, input_file_path = nil, explain = 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..."
+
+    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)
+  end
+
+  private
+
+  def handle_unsupported_language(lang)
+    warn "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)
+    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)
+    else
+      execute_direct_command(code_content, cmd_lambda, explain)
+    end
+  end
+
+  def execute_with_temp_file(code_content, cmd_lambda, temp_file_suffix, temp_dir, lang_key, input_file_path = nil, explain = 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)
+
+      # Extract output_path if present (for mermaid)
+      output_path = exec_options.delete(:output_path) if exec_options.is_a?(Hash)
+
+      captured_stdout, captured_stderr, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
+      result = {
+        stdout: captured_stdout,
+        stderr: captured_stderr,
+        status: captured_status_obj,
+        output_path: output_path # For mermaid SVG output
+      }
+    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)
+    captured_stdout, captured_stderr, captured_status_obj = Open3.capture3(command_to_run, **exec_options)
+    { stdout: captured_stdout, stderr: captured_stderr, status: captured_status_obj }
+  end
+
+  def process_execution_result(result, lang_config, lang_key, explain = 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)
+    end
+
+    result_output
+  end
+
+  def format_captured_output(result, lang_config)
+    result_output = result[:stdout]
+    stderr_output = result[:stderr]
+    exit_status = result[:status].exitstatus
+
+    # JS-specific: Append stderr to result if execution failed and stderr has content
+    if lang_config && lang_config[:error_handling] == :js_specific && exit_status != 0 && stderr_has_content?(stderr_output)
+      result_output += "\nStderr:\n#{stderr_output.strip}"
+    end
+
+    [exit_status, result_output, stderr_output]
+  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)
+
+    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
+      error_prefix = "Execution failed (status: #{exit_status})."
+      error_prefix += " Stderr: #{stderr_output.strip}" if stderr_has_content?(stderr_output)
+      result_output = "#{error_prefix}\n#{result_output}"
+    end
+    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}"
+      return "Error: SVG file not generated"
+    end
+
+    # Generate relative path for the SVG file
+    # If the SVG is in a subdirectory, include the directory in the path
+    output_dir = File.dirname(output_path)
+    svg_filename = File.basename(output_path)
+
+    # Check if SVG is in a subdirectory (new behavior) or same directory (fallback)
+    parent_dir = File.dirname(output_dir)
+    if File.basename(output_dir) != File.basename(parent_dir)
+      # SVG is in a subdirectory, use relative path with directory
+      relative_path = "#{File.basename(output_dir)}/#{svg_filename}"
+    else
+      # SVG is in same directory (fallback behavior)
+      relative_path = svg_filename
+    end
+
+    warn "Generated Mermaid SVG: #{relative_path}"
+
+    # Return markdown image tag instead of typical result content
+    "![Mermaid Diagram](#{relative_path})"
+  end
+
+  def handle_psql_explain_result(result_output)
+    require 'json'
+    require 'net/http'
+    require 'uri'
+
+    # Try to parse the result as JSON (EXPLAIN output)
+    begin
+      # Clean up the result output and try to parse as JSON
+      json_data = JSON.parse(result_output.strip)
+
+      # Submit plan to Dalibo via POST request
+      dalibo_url = submit_plan_to_dalibo(JSON.generate(json_data))
+
+      if dalibo_url
+        # Return a special format that the markdown processor can parse
+        "DALIBO_LINK:#{dalibo_url}\n#{result_output.strip}"
+      else
+        # If submission failed, just return the original output
+        result_output
+      end
+    rescue JSON::ParserError
+      # If it's not valid JSON, just return the original output
+      result_output
+    end
+  end
+
+  private
+
+  def submit_plan_to_dalibo(plan_json)
+    begin
+      # Start with HTTPS directly to avoid the HTTP->HTTPS redirect
+      uri = URI('https://explain.dalibo.com/new')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.read_timeout = 10  # 10 seconds timeout
+
+      # Prepare the JSON payload
+      payload = {
+        'plan' => plan_json,
+        'title' => "Query Plan - #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}",
+        'query' => ''
+      }
+
+      # Create the POST request
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      request.body = JSON.generate(payload)
+
+      # Send the request and follow redirects to get the final URL
+      response = http.request(request)
+
+      # Dalibo returns a redirect to the plan URL
+      if response.is_a?(Net::HTTPRedirection)
+        location = response['location']
+        # Make sure it's a full URL
+        if location
+          if location.start_with?('/')
+            location = "https://explain.dalibo.com#{location}"
+          end
+          location
+        else
+          nil
+        end
+      else
+        warn "Failed to submit plan to Dalibo: #{response.code} #{response.message}"
+        nil
+      end
+    rescue => e
+      warn "Error submitting plan to Dalibo: #{e.message}"
+      nil
+    end
+  end
+end

data/lib/enum_helper.rb

@@ -0,0 +1,17 @@
+module EnumHelper
+  private
+
+  def safe_enum_operation(file_enum, operation)
+    file_enum.send(operation)
+  rescue StopIteration
+    nil
+  end
+
+  def get_next_line(file_enum)
+    safe_enum_operation(file_enum, :next)
+  end
+
+  def peek_next_line(file_enum)
+    safe_enum_operation(file_enum, :peek)
+  end
+end

data/lib/execution_decider.rb

@@ -0,0 +1,225 @@
+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)
+    @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_result = current_block_result
+  end
+
+  def decide(file_enum, result_block_regex_method)
+    return skip_execution_run_false if run_disabled?
+
+    expected_header_regex = result_block_regex_method.call(@current_block_lang)
+    peek1 = peek_next_line(file_enum)
+
+    if line_matches_pattern?(peek1, expected_header_regex)
+      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)
+      handle_immediate_dalibo_link(file_enum)
+    else
+      execute_without_existing_result
+    end
+  end
+
+  private
+
+  def run_disabled?
+    !@current_block_run
+  end
+
+  def skip_execution_run_false
+    { execute: false, lines_to_pass_through: [] }
+  end
+
+  def handle_immediate_result_block(file_enum)
+    if @current_block_rerun
+      execute_with_consumed_result(file_enum)
+    else
+      skip_with_existing_result(file_enum)
+    end
+  end
+
+  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
+      peek2 = peek_next_line(file_enum)
+    end
+
+    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)
+      handle_dalibo_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    else
+      execute_with_blank_lines(consumed_blank_line, additional_blanks)
+    end
+  end
+
+  def handle_result_after_blank_line(file_enum, consumed_blank_line)
+    if @current_block_rerun
+      execute_with_consumed_result_and_blank(file_enum, consumed_blank_line)
+    else
+      skip_with_blank_and_result(file_enum, consumed_blank_line)
+    end
+  end
+
+  def handle_result_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    if @current_block_rerun
+      execute_with_consumed_result_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    else
+      skip_with_blanks_and_result(file_enum, consumed_blank_line, additional_blanks)
+    end
+  end
+
+  def handle_dalibo_after_blank_lines(file_enum, consumed_blank_line, additional_blanks)
+    # For explain result=false, always replace existing Dalibo links
+    # For explain result=true, follow normal rerun logic
+    if should_auto_replace_dalibo_link? || @current_block_rerun
+      execute_with_consumed_dalibo_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    else
+      skip_with_blanks_and_dalibo(file_enum, consumed_blank_line, additional_blanks)
+    end
+  end
+
+  def execute_with_consumed_result(file_enum)
+    consumed_lines = [file_enum.next]
+    { execute: true, consumed_lines: consumed_lines, consume_existing: true }
+  end
+
+  def skip_with_existing_result(file_enum)
+    { execute: false, lines_to_pass_through: [file_enum.next] }
+  end
+
+  def execute_with_consumed_result_and_blank(file_enum, consumed_blank_line)
+    consumed_lines = [consumed_blank_line, file_enum.next]
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing: true }
+  end
+
+  def skip_with_blank_and_result(file_enum, consumed_blank_line)
+    { execute: false, lines_to_pass_through: [consumed_blank_line, file_enum.next] }
+  end
+
+  def execute_with_blank_line(consumed_blank_line)
+    { execute: true, blank_line: consumed_blank_line }
+  end
+
+  def execute_with_blank_lines(consumed_blank_line, additional_blanks)
+    { execute: true, blank_line: consumed_blank_line, additional_blanks: additional_blanks }
+  end
+
+  def execute_with_consumed_result_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks + [file_enum.next]
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing: true }
+  end
+
+  def skip_with_blanks_and_result(file_enum, consumed_blank_line, additional_blanks)
+    lines_to_pass = [consumed_blank_line] + additional_blanks + [file_enum.next]
+    { execute: false, lines_to_pass_through: lines_to_pass }
+  end
+
+  def execute_with_consumed_dalibo_and_blanks(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing_dalibo: true }
+  end
+
+  def skip_with_blanks_and_dalibo(file_enum, consumed_blank_line, additional_blanks)
+    consumed_lines = [consumed_blank_line] + additional_blanks
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, dalibo_content: true }
+  end
+
+  def execute_without_existing_result
+    { execute: true }
+  end
+
+  def handle_immediate_dalibo_link(file_enum)
+    # For explain result=false, always replace existing Dalibo links
+    # For explain result=true, follow normal rerun logic
+    if should_auto_replace_dalibo_link? || @current_block_rerun
+      execute_with_consumed_dalibo(file_enum)
+    else
+      skip_with_existing_dalibo(file_enum)
+    end
+  end
+
+  def handle_dalibo_after_blank_line(file_enum, consumed_blank_line)
+    # For explain result=false, always replace existing Dalibo links
+    # For explain result=true, follow normal rerun logic
+    if should_auto_replace_dalibo_link? || @current_block_rerun
+      execute_with_consumed_dalibo_and_blank(file_enum, consumed_blank_line)
+    else
+      skip_with_blank_and_dalibo(file_enum, consumed_blank_line)
+    end
+  end
+
+  def execute_with_consumed_dalibo(file_enum)
+    consumed_lines = []
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, consume_existing_dalibo: true }
+  end
+
+  def skip_with_existing_dalibo(file_enum)
+    consumed_lines = []
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, dalibo_content: true }
+  end
+
+  def execute_with_consumed_dalibo_and_blank(file_enum, consumed_blank_line)
+    consumed_lines = [consumed_blank_line]
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: true, consumed_lines: consumed_lines, blank_line: consumed_blank_line, consume_existing_dalibo: true }
+  end
+
+  def skip_with_blank_and_dalibo(file_enum, consumed_blank_line)
+    consumed_lines = [consumed_blank_line]
+    consume_dalibo_links(file_enum, consumed_lines)
+    { execute: false, lines_to_pass_through: consumed_lines, dalibo_content: true }
+  end
+
+  def consume_dalibo_links(file_enum, consumed_lines)
+    # 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
+      else
+        break
+      end
+    end
+  end
+
+  def is_dalibo_link?(line)
+    line&.start_with?("**Dalibo Visualization:**")
+  end
+
+  def line_matches_pattern?(line, pattern)
+    line && line.match?(pattern)
+  end
+
+  def is_blank_line?(line)
+    line && line.strip == ""
+  end
+
+  def should_auto_replace_dalibo_link?
+    # Auto-replace Dalibo links when using explain 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
+  end
+end

data/lib/frontmatter_parser.rb

@@ -0,0 +1,72 @@
+require "yaml"
+require_relative "enum_helper"
+
+class FrontmatterParser
+  include EnumHelper
+
+  def initialize
+    @aliases = {}
+  end
+
+  attr_reader :aliases
+
+  def parse_frontmatter(file_enum, output_lines)
+    first_line = peek_next_line(file_enum)
+    return unless first_line&.strip == "---"
+
+    frontmatter_lines = collect_frontmatter_lines(file_enum, output_lines)
+    process_frontmatter_content(frontmatter_lines) unless frontmatter_lines.empty?
+  end
+
+  def resolve_language(lang)
+    @aliases[lang] || lang
+  end
+
+  private
+
+  def collect_frontmatter_lines(file_enum, output_lines)
+    # Consume the opening ---
+    output_lines << file_enum.next
+    frontmatter_lines = []
+
+    loop do
+      line = get_next_line(file_enum)
+      break unless line
+
+      if line.strip == "---"
+        output_lines << line
+        break
+      end
+
+      frontmatter_lines << line
+      output_lines << line
+    end
+
+    frontmatter_lines
+  end
+
+  def process_frontmatter_content(frontmatter_lines)
+    begin
+      frontmatter = YAML.safe_load(frontmatter_lines.join)
+      extract_aliases(frontmatter) if frontmatter.is_a?(Hash)
+    rescue YAML::SyntaxError => e
+      warn "Warning: Invalid YAML frontmatter: #{e.message}"
+    end
+  end
+
+  def extract_aliases(frontmatter)
+    markdown_run_config = frontmatter["markdown-run"]
+    return unless markdown_run_config.is_a?(Hash)
+
+    aliases = markdown_run_config["alias"]
+    return unless 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
+end

data/lib/language_configs.rb

@@ -1,5 +1,7 @@
+require 'securerandom'
+
 JS_CONFIG = {
-  command: ->(_code_content, temp_file_path) {
+  command: ->(_code_content, temp_file_path, input_file_path = nil, explain = false) {
     # Check if bun is available
     bun_exists = system("command -v bun > /dev/null 2>&1")
     if bun_exists
@@ -14,22 +16,32 @@ JS_CONFIG = {
 }.freeze
 
 SQLITE_CONFIG = {
-  command: ->(code_content, temp_file_path) { [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
+  command: ->(code_content, temp_file_path, input_file_path = nil, explain = 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) {
+    command: ->(code_content, _temp_file_path, input_file_path = nil, explain = 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
-      [ "psql -A -t -X", { stdin_data: code_content } ]
+
+      # Modify the SQL query if explain option is enabled
+      if explain
+        # 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*$/, '')
+        explained_query = "EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) #{clean_query};"
+        [ "psql -A -t -X", { stdin_data: explained_query } ]
+      else
+        [ "psql -A -t -X", { stdin_data: code_content } ]
+      end
     }
   },
   "ruby" => {
-    command: ->(_code_content, temp_file_path) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = 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."
@@ -45,7 +57,7 @@ SUPPORTED_LANGUAGES = {
   "sqlite" => SQLITE_CONFIG,
   "sqlite3" => SQLITE_CONFIG, # Alias for sqlite
   "bash" => {
-    command: ->(_code_content, temp_file_path) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = 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."
@@ -55,7 +67,7 @@ SUPPORTED_LANGUAGES = {
     temp_file_suffix: ".sh"
   },
   "zsh" => {
-    command: ->(_code_content, temp_file_path) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = 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."
@@ -65,7 +77,7 @@ SUPPORTED_LANGUAGES = {
     temp_file_suffix: ".zsh"
   },
   "sh" => {
-    command: ->(_code_content, temp_file_path) {
+    command: ->(_code_content, temp_file_path, input_file_path = nil, explain = 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."
@@ -73,6 +85,39 @@ SUPPORTED_LANGUAGES = {
       [ "sh #{temp_file_path}", {} ]
     },
     temp_file_suffix: ".sh"
+  },
+  "mermaid" => {
+    command: ->(code_content, temp_file_path, input_file_path = nil, explain = 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"
+      end
+
+      # Generate SVG output file path with directory structure based on markdown file
+      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}-#{timestamp}-#{random_suffix}.svg"
+        output_path = File.join(output_dir, svg_filename)
+      else
+        # Fallback to old behavior if no input file path provided
+        input_dir = File.dirname(temp_file_path)
+        base_name = File.basename(temp_file_path, ".*")
+        output_path = File.join(input_dir, "#{base_name}.svg")
+      end
+
+      [ "mmdc -i #{temp_file_path} -o #{output_path}", { output_path: output_path } ]
+    },
+    temp_file_suffix: ".mmd",
+    result_handling: :mermaid_svg # Special handling for SVG generation
   }
 }.freeze
 

data/lib/markdown/run/version.rb

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

data/lib/markdown_file_writer.rb

@@ -0,0 +1,25 @@
+require "tempfile"
+require "fileutils"
+
+class MarkdownFileWriter
+  def self.write_output_to_file(output_lines, input_file_path)
+    temp_dir = File.dirname(File.expand_path(input_file_path))
+
+    # Write the modified content back to the input file using atomic operations
+    Tempfile.create([ "md_exec_out_", File.extname(input_file_path) ], temp_dir) do |temp_output_file|
+      temp_output_file.write(output_lines.join(""))
+      temp_output_file.close
+
+      begin
+        FileUtils.mv(temp_output_file.path, input_file_path)
+      rescue Errno::EACCES, Errno::EXDEV
+        warn "Atomic move failed. Falling back to copy and delete."
+        FileUtils.cp(temp_output_file.path, input_file_path)
+        FileUtils.rm_f(temp_output_file.path)
+      end
+    end
+
+    warn "Markdown processing complete. Output written to #{input_file_path}"
+    true # Indicate success
+  end
+end