asciinema_win 0.1.0

data/lib/asciinema_win/export.rb

@@ -0,0 +1,780 @@
+# frozen_string_literal: true
+
+module AsciinemaWin
+  # Export module for converting recordings to different formats
+  #
+  # Supports export to:
+  # - Cast (asciicast v2 - copy/convert)
+  # - HTML (embedded player)
+  # - SVG (static snapshot)
+  # - Text (plain text dump)
+  # - JSON (normalized format)
+  # - GIF/MP4/WebM (requires FFmpeg - optional)
+  #
+  # @note Video export requires FFmpeg installed and in PATH.
+  #       This is an OPTIONAL feature - core functionality works without it.
+  module Export
+    # Export formats supported natively (no external dependencies)
+    NATIVE_FORMATS = %i[cast html svg txt text json].freeze
+
+    # Export formats requiring external tools
+    EXTERNAL_FORMATS = %i[gif mp4 webm].freeze
+
+    # All supported formats
+    ALL_FORMATS = (NATIVE_FORMATS + EXTERNAL_FORMATS).freeze
+
+    class << self
+      # Export a recording to the specified format
+      #
+      # @param input_path [String] Path to the .cast file
+      # @param output_path [String] Path for the output file
+      # @param format [Symbol] Output format (:cast, :html, :svg, :txt, :json, :gif, :mp4, :webm)
+      # @param options [Hash] Format-specific options
+      # @return [Boolean] True if export succeeded
+      # @raise [ExportError] If export fails
+      def export(input_path, output_path, format:, **options)
+        format = format.to_sym
+
+        unless ALL_FORMATS.include?(format)
+          raise ExportError, "Unsupported format: #{format}. Supported: #{ALL_FORMATS.join(", ")}"
+        end
+
+        case format
+        when :cast
+          export_cast(input_path, output_path, **options)
+        when :html
+          export_html(input_path, output_path, **options)
+        when :svg
+          export_svg(input_path, output_path, **options)
+        when :txt, :text
+          export_text(input_path, output_path, **options)
+        when :json
+          export_json(input_path, output_path, **options)
+        when :gif, :mp4, :webm
+          export_video(input_path, output_path, format: format, **options)
+        end
+      end
+
+      # Export to asciicast v2 format (copy or transform)
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .cast file
+      # @param title [String, nil] New title (optional)
+      # @param trim_start [Float, nil] Trim seconds from start
+      # @param trim_end [Float, nil] Trim seconds from end
+      # @param speed [Float] Speed multiplier (1.0 = normal, 2.0 = 2x faster)
+      # @param max_idle [Float, nil] Maximum idle time between events
+      # @return [Boolean] Success
+      def export_cast(input_path, output_path, title: nil, trim_start: nil, trim_end: nil, speed: 1.0, max_idle: nil, **_options)
+        reader = Asciicast.load(input_path)
+        original_header = reader.header
+
+        # Create new header with potential modifications
+        new_header = Asciicast::Header.new(
+          width: original_header.width,
+          height: original_header.height,
+          timestamp: original_header.timestamp,
+          idle_time_limit: max_idle || original_header.idle_time_limit,
+          command: original_header.command,
+          title: title || original_header.title,
+          env: original_header.env,
+          theme: original_header.theme
+        )
+
+        File.open(output_path, "w", encoding: "UTF-8") do |file|
+          writer = Asciicast::Writer.new(file, new_header)
+          last_time = 0.0
+
+          reader.each_event do |event|
+            # Apply trimming if specified
+            next if trim_start && event.time < trim_start
+            next if trim_end && event.time > trim_end
+
+            # Adjust time for trimming
+            adjusted_time = trim_start ? event.time - trim_start : event.time
+
+            # Apply speed adjustment
+            adjusted_time /= speed
+
+            # Apply max idle limit
+            if max_idle && (adjusted_time - last_time) > max_idle
+              adjusted_time = last_time + max_idle
+            end
+
+            writer.write_event(Asciicast::Event.new(adjusted_time, event.type, event.data))
+            last_time = adjusted_time
+          end
+
+          writer.close
+        end
+
+        true
+      end
+
+      # Concatenate multiple recordings into one
+      #
+      # @param input_paths [Array<String>] Paths to .cast files to concatenate
+      # @param output_path [String] Output .cast file path
+      # @param title [String, nil] Title for combined recording
+      # @param gap [Float] Gap in seconds between recordings
+      # @return [Boolean] Success
+      def concatenate(input_paths, output_path, title: nil, gap: 1.0)
+        raise ExportError, "No input files specified" if input_paths.empty?
+
+        # Load first file to get dimensions
+        first_reader = Asciicast.load(input_paths.first)
+        first_header = first_reader.header
+
+        # Determine max dimensions across all files
+        max_width = first_header.width
+        max_height = first_header.height
+
+        input_paths[1..].each do |path|
+          reader = Asciicast.load(path)
+          max_width = [max_width, reader.header.width].max
+          max_height = [max_height, reader.header.height].max
+        end
+
+        # Create output header
+        combined_title = title || input_paths.map { |p| File.basename(p, ".cast") }.join(" + ")
+        new_header = Asciicast::Header.new(
+          width: max_width,
+          height: max_height,
+          timestamp: first_header.timestamp,
+          title: combined_title
+        )
+
+        File.open(output_path, "w", encoding: "UTF-8") do |file|
+          writer = Asciicast::Writer.new(file, new_header)
+          current_time = 0.0
+
+          input_paths.each_with_index do |path, index|
+            reader = Asciicast.load(path)
+            last_event_time = 0.0
+
+            reader.each_event do |event|
+              writer.write_event(Asciicast::Event.new(current_time + event.time, event.type, event.data))
+              last_event_time = event.time
+            end
+
+            # Add gap before next recording (except after last)
+            current_time += last_event_time + gap if index < input_paths.length - 1
+
+            # Add marker at join point
+            if index < input_paths.length - 1
+              writer.write_marker(current_time - gap / 2, "joined: #{File.basename(path)}")
+            end
+          end
+
+          writer.close
+        end
+
+        true
+      end
+
+      # Generate a thumbnail image from a recording
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output image path (.svg or .png)
+      # @param frame [Symbol] Which frame (:first, :last, :middle)
+      # @param theme [String] Color theme
+      # @param width [Integer, nil] Override width in pixels
+      # @param height [Integer, nil] Override height in pixels
+      # @return [Boolean] Success
+      def thumbnail(input_path, output_path, frame: :last, theme: "asciinema", width: nil, height: nil, **_options)
+        info = Asciicast::Reader.info(input_path)
+        reader = Asciicast.load(input_path)
+
+        # Determine which frame to capture
+        target_time = case frame
+                      when :first then 0.0
+                      when :last then info[:duration]
+                      when :middle then info[:duration] / 2
+                      when Numeric then frame.to_f
+                      else info[:duration]
+                      end
+
+        # Collect output up to target time
+        output = StringIO.new
+        reader.each_event do |event|
+          break if event.time > target_time
+
+          output << event.data if event.output?
+        end
+
+        # Parse and render
+        color_theme = Themes.get(theme)
+        parser = AnsiParser.new(width: info[:width], height: info[:height])
+        lines = parser.parse(output.string)
+
+        svg = generate_thumbnail_svg(lines, info[:width], info[:height], color_theme, width: width, height: height)
+
+        File.write(output_path, svg, encoding: "UTF-8")
+        true
+      end
+
+      # Adjust playback speed of a recording
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .cast file
+      # @param speed [Float] Speed multiplier (2.0 = 2x faster)
+      # @param max_idle [Float, nil] Compress idle time to this maximum
+      # @return [Boolean] Success
+      def adjust_speed(input_path, output_path, speed: 1.0, max_idle: nil)
+        export_cast(input_path, output_path, speed: speed, max_idle: max_idle)
+      end
+
+      # Export to HTML with embedded asciinema-player
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .html file
+      # @param title [String] Page title
+      # @param theme [String] Player theme (asciinema, tango, solarized-dark, etc.)
+      # @param autoplay [Boolean] Auto-start playback
+      # @return [Boolean] Success
+      def export_html(input_path, output_path, title: nil, theme: "asciinema", autoplay: false, **_options)
+        info = Asciicast::Reader.info(input_path)
+        cast_content = File.read(input_path, encoding: "UTF-8")
+        title ||= info[:title] || "Terminal Recording"
+
+        html = generate_html(cast_content, info, title: title, theme: theme, autoplay: autoplay)
+
+        File.write(output_path, html, encoding: "UTF-8")
+        true
+      end
+
+      # Export to SVG with full color support
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .svg file
+      # @param theme [String] Color theme (asciinema, dracula, monokai, etc.)
+      # @param frame [Symbol] Which frame to capture (:first, :last, :all)
+      # @return [Boolean] Success
+      def export_svg(input_path, output_path, theme: "asciinema", frame: :last, **_options)
+        info = Asciicast::Reader.info(input_path)
+        reader = Asciicast.load(input_path)
+
+        # Collect all output
+        output = StringIO.new
+        reader.each_event do |event|
+          output << event.data if event.output?
+        end
+
+        # Parse ANSI codes and render colored SVG
+        color_theme = Themes.get(theme)
+        svg = generate_colored_svg(output.string, info[:width], info[:height], color_theme)
+
+        File.write(output_path, svg, encoding: "UTF-8")
+        true
+      end
+
+      # Export to plain text
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .txt file
+      # @param strip_ansi [Boolean] Remove ANSI escape sequences
+      # @return [Boolean] Success
+      def export_text(input_path, output_path, strip_ansi: true, **_options)
+        reader = Asciicast.load(input_path)
+
+        output = StringIO.new
+        reader.each_event do |event|
+          output << event.data if event.output?
+        end
+
+        text = output.string
+        text = strip_ansi_codes(text) if strip_ansi
+
+        File.write(output_path, text, encoding: "UTF-8")
+        true
+      end
+
+      # Export to JSON (normalized format)
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output .json file
+      # @return [Boolean] Success
+      def export_json(input_path, output_path, **_options)
+        require "json"
+
+        info = Asciicast::Reader.info(input_path)
+        reader = Asciicast.load(input_path)
+
+        events = reader.each_event.map do |event|
+          { time: event.time, type: event.type, data: event.data }
+        end
+
+        data = {
+          header: info,
+          events: events
+        }
+
+        File.write(output_path, JSON.pretty_generate(data), encoding: "UTF-8")
+        true
+      end
+
+      # Export to video format (GIF, MP4, WebM)
+      #
+      # @note Requires FFmpeg to be installed
+      #
+      # @param input_path [String] Input .cast file
+      # @param output_path [String] Output video file
+      # @param format [Symbol] Video format (:gif, :mp4, :webm)
+      # @param fps [Integer] Frames per second
+      # @param font_size [Integer] Font size in pixels
+      # @return [Boolean] Success
+      # @raise [ExportError] If FFmpeg is not available
+      def export_video(input_path, output_path, format:, fps: 10, font_size: 14, **_options)
+        unless ffmpeg_available?
+          raise ExportError, <<~MSG
+            FFmpeg is required for #{format.upcase} export but was not found.
+
+            To install FFmpeg:
+            1. Download from https://ffmpeg.org/download.html
+            2. Add to PATH or set FFMPEG_PATH environment variable
+
+            Alternatively, use native export formats: #{NATIVE_FORMATS.join(", ")}
+          MSG
+        end
+
+        # For video export, we need to:
+        # 1. Render each frame to an image
+        # 2. Use FFmpeg to combine into video
+        #
+        # This is a simplified implementation that creates a basic video
+        # For production use, consider using agg (asciinema/agg) or similar
+
+        warn "Video export is experimental. For best results, use https://github.com/asciinema/agg"
+
+        # Create temporary directory for frames
+        temp_dir = File.join(Dir.tmpdir, "asciinema_win_#{Process.pid}")
+        Dir.mkdir(temp_dir) unless Dir.exist?(temp_dir)
+
+        begin
+          # Generate frame images (simplified - just text rendering)
+          generate_video_frames(input_path, temp_dir, fps: fps, font_size: font_size)
+
+          # Use FFmpeg to create video
+          ffmpeg_create_video(temp_dir, output_path, format: format, fps: fps)
+
+          true
+        ensure
+          # Cleanup temp files
+          FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+        end
+      end
+
+      # Check if FFmpeg is available
+      #
+      # @return [Boolean] True if FFmpeg is in PATH
+      def ffmpeg_available?
+        ffmpeg_path = ENV["FFMPEG_PATH"] || "ffmpeg"
+        system("#{ffmpeg_path} -version", out: File::NULL, err: File::NULL)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      # Generate HTML with embedded player
+      def generate_html(cast_content, info, title:, theme:, autoplay:)
+        # Escape the cast content for embedding in JavaScript
+        escaped_cast = cast_content.gsub("\\", "\\\\\\\\")
+                                   .gsub("'", "\\\\'")
+                                   .gsub("\n", "\\n")
+                                   .gsub("\r", "\\r")
+
+        autoplay_attr = autoplay ? 'autoplay="true"' : ""
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>#{title}</title>
+            <link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/npm/asciinema-player@3.6.3/dist/bundle/asciinema-player.css" />
+            <style>
+              body {
+                margin: 0;
+                padding: 20px;
+                background: #1a1a2e;
+                font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+              }
+              .container {
+                max-width: 1000px;
+                margin: 0 auto;
+              }
+              h1 {
+                color: #eee;
+                margin-bottom: 20px;
+              }
+              .info {
+                color: #888;
+                margin-bottom: 20px;
+              }
+              #player {
+                border-radius: 8px;
+                overflow: hidden;
+              }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <h1>#{title}</h1>
+              <div class="info">
+                Size: #{info[:width]}x#{info[:height]} |
+                Duration: #{format("%.1f", info[:duration])}s |
+                Events: #{info[:event_count]}
+              </div>
+              <div id="player"></div>
+            </div>
+
+            <script src="https://cdn.jsdelivr.net/npm/asciinema-player@3.6.3/dist/bundle/asciinema-player.min.js"></script>
+            <script>
+              const castContent = '#{escaped_cast}';
+              const blob = new Blob([castContent], { type: 'text/plain' });
+              const url = URL.createObjectURL(blob);
+
+              AsciinemaPlayer.create(url, document.getElementById('player'), {
+                theme: '#{theme}',
+                #{autoplay_attr}
+                fit: 'width',
+                fontSize: 'medium'
+              });
+            </script>
+          </body>
+          </html>
+        HTML
+      end
+
+      # Generate colored SVG representation using ANSI parser
+      #
+      # @param content [String] Raw ANSI content
+      # @param width [Integer] Terminal width
+      # @param height [Integer] Terminal height
+      # @param theme [Themes::Theme] Color theme
+      # @return [String] SVG content
+      def generate_colored_svg(content, width, height, theme)
+        # Parse ANSI content
+        parser = AnsiParser.new(width: width, height: height)
+        lines = parser.parse(content)
+
+        char_width = 8.4
+        char_height = 18
+        padding = 16
+        border_radius = 8
+
+        svg_width = (width * char_width + padding * 2).ceil
+        svg_height = (height * char_height + padding * 2 + 30).ceil  # +30 for title bar
+
+        # Build SVG content
+        svg_content = StringIO.new
+
+        # Render each line
+        lines.each_with_index do |line, y|
+          y_pos = padding + 30 + (y + 1) * char_height  # +30 for title bar offset
+
+          # Group characters with same style for efficiency
+          x = 0
+          while x < line.chars.length
+            char_data = line.chars[x]
+
+            # Find run of characters with same style
+            run_start = x
+            while x < line.chars.length && line.chars[x].same_style?(char_data)
+              x += 1
+            end
+
+            # Skip if just spaces with default style
+            text = line.chars[run_start...x].map(&:char).join
+            next if text.match?(/^\s*$/) && char_data.default_style?
+
+            # Calculate position
+            x_pos = padding + run_start * char_width
+
+            # Build style attributes
+            styles = []
+            fill = resolve_fg_color(char_data.fg, theme)
+            styles << "fill:#{fill}" if fill != theme.foreground
+
+            bg = resolve_bg_color(char_data.bg, theme)
+            if bg && bg != theme.background
+              # Add background rectangle
+              bg_width = (x - run_start) * char_width
+              svg_content << %(<rect x="#{x_pos}" y="#{y_pos - char_height + 4}" width="#{bg_width}" height="#{char_height}" fill="#{bg}"/>)
+              svg_content << "\n"
+            end
+
+            styles << "font-weight:bold" if char_data.bold
+            styles << "font-style:italic" if char_data.italic
+
+            style_attr = styles.empty? ? "" : %( style="#{styles.join(";")}")
+
+            # Escape text for XML
+            escaped = text.gsub("&", "&amp;")
+                          .gsub("<", "&lt;")
+                          .gsub(">", "&gt;")
+                          .gsub("'", "&apos;")
+                          .gsub('"', "&quot;")
+
+            # Add decorations
+            decorations = []
+            decorations << "underline" if char_data.underline
+            decorations << "line-through" if char_data.strikethrough
+            dec_attr = decorations.empty? ? "" : %( text-decoration="#{decorations.join(" ")}")
+
+            svg_content << %(<text x="#{x_pos}" y="#{y_pos}" class="t"#{style_attr}#{dec_attr}>#{escaped}</text>)
+            svg_content << "\n"
+          end
+        end
+
+        # Window button colors
+        close_color = "#ff5f56"
+        minimize_color = "#ffbd2e"
+        maximize_color = "#27c93f"
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" width="#{svg_width}" height="#{svg_height}" viewBox="0 0 #{svg_width} #{svg_height}">
+            <defs>
+              <style>
+                .bg { fill: #{theme.background}; }
+                .title-bar { fill: #{darken_color(theme.background, 0.15)}; }
+                .t {
+                  font-family: "Cascadia Code", "Fira Code", "Consolas", "Monaco", "Courier New", monospace;
+                  font-size: 14px;
+                  fill: #{theme.foreground};
+                  white-space: pre;
+                }
+              </style>
+            </defs>
+
+            <!-- Window frame -->
+            <rect class="bg" width="100%" height="100%" rx="#{border_radius}"/>
+
+            <!-- Title bar -->
+            <rect class="title-bar" width="100%" height="30" rx="#{border_radius}" ry="#{border_radius}"/>
+            <rect class="title-bar" y="#{border_radius}" width="100%" height="#{30 - border_radius}"/>
+
+            <!-- Window buttons -->
+            <circle cx="20" cy="15" r="6" fill="#{close_color}"/>
+            <circle cx="40" cy="15" r="6" fill="#{minimize_color}"/>
+            <circle cx="60" cy="15" r="6" fill="#{maximize_color}"/>
+
+            <!-- Terminal content -->
+            <g class="terminal">
+          #{svg_content.string}    </g>
+          </svg>
+        SVG
+      end
+
+      # Generate thumbnail SVG (smaller, simplified)
+      #
+      # @param lines [Array<ParsedLine>] Parsed lines
+      # @param term_width [Integer] Terminal width
+      # @param term_height [Integer] Terminal height
+      # @param theme [Themes::Theme] Color theme
+      # @param width [Integer, nil] Override width
+      # @param height [Integer, nil] Override height
+      # @return [String] SVG content
+      def generate_thumbnail_svg(lines, term_width, term_height, theme, width: nil, height: nil)
+        # Calculate dimensions
+        char_width = 6.0
+        char_height = 12.0
+        padding = 8
+        border_radius = 6
+        title_bar_height = 20
+
+        svg_width = width || (term_width * char_width + padding * 2).ceil
+        svg_height = height || (term_height * char_height + padding * 2 + title_bar_height).ceil
+
+        # Scale factor if custom dimensions provided
+        scale_x = width ? width.to_f / (term_width * char_width + padding * 2) : 1.0
+        scale_y = height ? height.to_f / (term_height * char_height + padding * 2 + title_bar_height) : 1.0
+
+        # Build SVG content
+        svg_content = StringIO.new
+
+        # Render each line (simplified)
+        lines.each_with_index do |line, y|
+          y_pos = (padding + title_bar_height + (y + 1) * char_height) * scale_y
+
+          x = 0
+          while x < line.chars.length
+            char_data = line.chars[x]
+
+            run_start = x
+            while x < line.chars.length && line.chars[x].same_style?(char_data)
+              x += 1
+            end
+
+            text = line.chars[run_start...x].map(&:char).join
+            next if text.match?(/^\s*$/) && char_data.default_style?
+
+            x_pos = (padding + run_start * char_width) * scale_x
+            fill = resolve_fg_color(char_data.fg, theme)
+            style = fill != theme.foreground ? %( style="fill:#{fill}") : ""
+
+            escaped = text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+            svg_content << %(<text x="#{x_pos}" y="#{y_pos}" class="t"#{style}>#{escaped}</text>\n)
+          end
+        end
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" width="#{svg_width}" height="#{svg_height}">
+            <defs>
+              <style>
+                .bg { fill: #{theme.background}; }
+                .bar { fill: #{darken_color(theme.background, 0.15)}; }
+                .t {
+                  font-family: monospace;
+                  font-size: #{(10 * scale_y).round}px;
+                  fill: #{theme.foreground};
+                }
+              </style>
+            </defs>
+            <rect class="bg" width="100%" height="100%" rx="#{border_radius}"/>
+            <rect class="bar" width="100%" height="#{title_bar_height}" rx="#{border_radius}"/>
+            <circle cx="12" cy="10" r="4" fill="#ff5f56"/>
+            <circle cx="26" cy="10" r="4" fill="#ffbd2e"/>
+            <circle cx="40" cy="10" r="4" fill="#27c93f"/>
+            <g class="content">
+          #{svg_content.string}    </g>
+          </svg>
+        SVG
+      end
+
+      # Resolve foreground color from ANSI code to hex
+      #
+      # @param fg [Integer, String, nil] Foreground color
+      # @param theme [Themes::Theme] Color theme
+      # @return [String] Hex color
+      def resolve_fg_color(fg, theme)
+        return theme.foreground if fg.nil?
+        return fg if fg.is_a?(String) && fg.start_with?("#")
+
+        case fg
+        when 30..37
+          theme.fg_color(fg)
+        when 90..97
+          theme.fg_color(fg)
+        when Integer
+          theme.color(fg)
+        else
+          theme.foreground
+        end
+      end
+
+      # Resolve background color from ANSI code to hex
+      #
+      # @param bg [Integer, String, nil] Background color
+      # @param theme [Themes::Theme] Color theme
+      # @return [String, nil] Hex color or nil
+      def resolve_bg_color(bg, theme)
+        return nil if bg.nil?
+        return bg if bg.is_a?(String) && bg.start_with?("#")
+
+        case bg
+        when 40..47
+          theme.bg_color(bg)
+        when 100..107
+          theme.bg_color(bg)
+        when Integer
+          theme.color(bg)
+        else
+          nil
+        end
+      end
+
+      # Darken a hex color
+      #
+      # @param hex [String] Hex color (#rrggbb)
+      # @param factor [Float] Darken factor (0-1)
+      # @return [String] Darkened hex color
+      def darken_color(hex, factor)
+        hex = hex.delete("#")
+        r = [(hex[0..1].to_i(16) * (1 - factor)).round, 0].max
+        g = [(hex[2..3].to_i(16) * (1 - factor)).round, 0].max
+        b = [(hex[4..5].to_i(16) * (1 - factor)).round, 0].max
+        format("#%02x%02x%02x", r, g, b)
+      end
+
+      # Generate SVG representation (legacy, no colors)
+      def generate_svg(content, width, height)
+        # Strip ANSI codes for SVG (simplified)
+        text = strip_ansi_codes(content)
+        lines = text.split("\n")
+
+        char_width = 8
+        char_height = 16
+        padding = 20
+
+        svg_width = width * char_width + padding * 2
+        svg_height = height * char_height + padding * 2
+
+        svg_lines = lines.first(height).map.with_index do |line, y|
+          escaped = line.gsub("&", "&amp;")
+                        .gsub("<", "&lt;")
+                        .gsub(">", "&gt;")
+          y_pos = padding + (y + 1) * char_height
+          %(<text x="#{padding}" y="#{y_pos}" class="line">#{escaped}</text>)
+        end.join("\n")
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" width="#{svg_width}" height="#{svg_height}">
+            <style>
+              .bg { fill: #1a1a2e; }
+              .line {
+                font-family: "Consolas", "Monaco", "Courier New", monospace;
+                font-size: 14px;
+                fill: #eee;
+              }
+            </style>
+            <rect class="bg" width="100%" height="100%" rx="8"/>
+            #{svg_lines}
+          </svg>
+        SVG
+      end
+
+      # Strip ANSI escape codes from text
+      def strip_ansi_codes(text)
+        # Remove all ANSI escape sequences
+        text.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
+            .gsub(/\e\][^\a]*\a/, "")  # OSC sequences
+            .gsub(/\r/, "")             # Carriage returns
+      end
+
+      # Generate video frames (placeholder - needs proper implementation)
+      def generate_video_frames(input_path, temp_dir, fps:, font_size:)
+        # This is a simplified placeholder
+        # Full implementation would render each frame to PNG
+        warn "Frame generation not fully implemented - using placeholder"
+      end
+
+      # Use FFmpeg to create video from frames
+      def ffmpeg_create_video(temp_dir, output_path, format:, fps:)
+        ffmpeg = ENV["FFMPEG_PATH"] || "ffmpeg"
+
+        case format
+        when :gif
+          # GIF creation
+          cmd = "#{ffmpeg} -y -framerate #{fps} -i #{temp_dir}/frame_%04d.png -vf \"palettegen\" #{temp_dir}/palette.png"
+          system(cmd, out: File::NULL, err: File::NULL)
+
+          cmd = "#{ffmpeg} -y -framerate #{fps} -i #{temp_dir}/frame_%04d.png -i #{temp_dir}/palette.png -lavfi \"paletteuse\" #{output_path}"
+          system(cmd, out: File::NULL, err: File::NULL)
+        when :mp4
+          cmd = "#{ffmpeg} -y -framerate #{fps} -i #{temp_dir}/frame_%04d.png -c:v libx264 -pix_fmt yuv420p #{output_path}"
+          system(cmd, out: File::NULL, err: File::NULL)
+        when :webm
+          cmd = "#{ffmpeg} -y -framerate #{fps} -i #{temp_dir}/frame_%04d.png -c:v libvpx-vp9 #{output_path}"
+          system(cmd, out: File::NULL, err: File::NULL)
+        end
+      end
+    end
+  end
+end
+