shellfie 0.1.1 → 1.1.0

data/lib/shellfie/ansi_parser.rb

@@ -1,62 +1,70 @@
 # frozen_string_literal: true
 
 require "strscan"
+require "uri"
+require_relative "ansi_colors"
+require_relative "ansi_normalizer"
+require_relative "errors"
 
 module Shellfie
-  Segment = Struct.new(:text, :foreground, :background, :bold, :italic, :underline, keyword_init: true)
+  Segment = Struct.new(
+    :text,
+    :foreground,
+    :background,
+    :bold,
+    :italic,
+    :underline,
+    :underline_style,
+    :underline_color,
+    :dim,
+    :reverse,
+    :strikethrough,
+    :overline,
+    :blink,
+    :conceal,
+    :link,
+    keyword_init: true
+  )
 
   class AnsiParser
-    ANSI_REGEX = /\e\[([0-9;]*)m/
-
-    COLORS = {
-      30 => :black,
-      31 => :red,
-      32 => :green,
-      33 => :yellow,
-      34 => :blue,
-      35 => :magenta,
-      36 => :cyan,
-      37 => :white,
-      90 => :bright_black,
-      91 => :bright_red,
-      92 => :bright_green,
-      93 => :bright_yellow,
-      94 => :bright_blue,
-      95 => :bright_magenta,
-      96 => :bright_cyan,
-      97 => :bright_white
-    }.freeze
-
-    BG_COLORS = {
-      40 => :black,
-      41 => :red,
-      42 => :green,
-      43 => :yellow,
-      44 => :blue,
-      45 => :magenta,
-      46 => :cyan,
-      47 => :white,
-      100 => :bright_black,
-      101 => :bright_red,
-      102 => :bright_green,
-      103 => :bright_yellow,
-      104 => :bright_blue,
-      105 => :bright_magenta,
-      106 => :bright_cyan,
-      107 => :bright_white
-    }.freeze
-
-    def initialize
+    ANSI_REGEX = /\e\[([0-9;:]*)m/
+
+    OSC_REGEX = /\e\](.*?)?(?:\a|\e\\)/m
+    MAX_LINK_BYTES = 2_048
+    MAX_OSC_BYTES = MAX_LINK_BYTES + 64
+    LINK_SCHEMES = %w[http https mailto].freeze
+
+    def initialize(state_mode: :persistent, tab_width: 8, osc_policy: "ignore", graphics_policy: "ignore")
+      @state_mode = state_mode.to_sym
+      @tab_width = tab_width
+      @osc_policy = osc_policy.to_s
+      @graphics_policy = graphics_policy.to_s
+      @link = nil
+      @pending_osc = +""
       reset_state
     end
 
     def parse(text)
+      if @state_mode == :line
+        reset_state
+        @link = nil
+      end
+
+      input = @pending_osc + text.to_s
+      reject_terminal_graphics!(input)
+      input, @pending_osc = split_incomplete_osc(input)
       segments = []
-      scanner = StringScanner.new(text)
+      scanner = StringScanner.new(AnsiNormalizer.normalize(input, tab_width: @tab_width, osc_policy: @osc_policy))
       current_text = +""
 
-      while !scanner.eos?
-        if scanner.scan(ANSI_REGEX)
+      until scanner.eos?
+        if scanner.scan(OSC_REGEX)
+          unless current_text.empty?
+            segments << create_segment(current_text)
+            current_text = +""
+          end
+          process_osc(scanner[1])
+        elsif scanner.scan(ANSI_REGEX)
           unless current_text.empty?
             segments << create_segment(current_text)
             current_text = +""
@@ -73,12 +81,26 @@ module Shellfie
 
     private
 
+    def reject_terminal_graphics!(text)
+      return unless @graphics_policy == "error" && text.match?(AnsiNormalizer::GRAPHICS_CONTROL_PREFIX)
+
+      raise ValidationError, "Terminal graphics are not supported; use window.graphics_policy: ignore to discard them"
+    end
+
     def reset_state
       @foreground = nil
       @background = nil
       @bold = false
       @italic = false
       @underline = false
+      @underline_style = nil
+      @underline_color = nil
+      @dim = false
+      @reverse = false
+      @strikethrough = false
+      @overline = false
+      @blink = false
+      @conceal = false
     end
 
     def create_segment(text)
@@ -88,87 +110,144 @@ module Shellfie
         background: @background,
         bold: @bold,
         italic: @italic,
-        underline: @underline
+        underline: @underline,
+        underline_style: @underline_style,
+        underline_color: @underline_color,
+        dim: @dim,
+        reverse: @reverse,
+        strikethrough: @strikethrough,
+        overline: @overline,
+        blink: @blink,
+        conceal: @conceal,
+        link: @link
       )
     end
 
     def process_codes(codes_str)
       return reset_state if codes_str.empty?
 
-      codes = codes_str.split(";").map(&:to_i)
+      codes = sgr_codes(codes_str)
       i = 0
 
       while i < codes.length
         code = codes[i]
 
+        if code.is_a?(Array) && code.first == :underline_style
+          @underline_style = %i[none single double curly dotted dashed][code.last]
+          @underline = @underline_style && @underline_style != :none
+          i += 1
+          next
+        end
+
         case code
         when 0
           reset_state
         when 1
           @bold = true
+        when 2
+          @dim = true
         when 3
           @italic = true
         when 4
           @underline = true
+          @underline_style = :single
+        when 5, 6
+          @blink = true
+        when 8
+          @conceal = true
+        when 7
+          @reverse = true
+        when 9
+          @strikethrough = true
         when 22
           @bold = false
+          @dim = false
         when 23
           @italic = false
         when 24
           @underline = false
+          @underline_style = nil
+        when 25
+          @blink = false
+        when 27
+          @reverse = false
+        when 28
+          @conceal = false
+        when 29
+          @strikethrough = false
         when 30..37, 90..97
-          @foreground = COLORS[code]
+          @foreground = AnsiColors::COLORS[code]
         when 38
-          i, @foreground = parse_extended_color(codes, i)
+          i, @foreground = AnsiColors.parse_extended_color(codes, i)
         when 39
           @foreground = nil
         when 40..47, 100..107
-          @background = BG_COLORS[code]
+          @background = AnsiColors::BG_COLORS[code]
         when 48
-          i, @background = parse_extended_color(codes, i)
+          i, @background = AnsiColors.parse_extended_color(codes, i)
         when 49
           @background = nil
+        when 21
+          @underline = true
+          @underline_style = :double
+        when 53
+          @overline = true
+        when 55
+          @overline = false
+        when 58
+          i, @underline_color = AnsiColors.parse_extended_color(codes, i)
+        when 59
+          @underline_color = nil
         end
 
         i += 1
       end
     end
 
-    def parse_extended_color(codes, i)
-      return [i, nil] if codes[i + 1].nil?
-
-      case codes[i + 1]
-      when 5
-        color_index = codes[i + 2]
-        [i + 2, color_256(color_index)]
-      when 2
-        r, g, b = codes[i + 2], codes[i + 3], codes[i + 4]
-        [i + 4, format("#%02x%02x%02x", r, g, b)]
-      else
-        [i, nil]
+    def sgr_codes(value)
+      value.split(";").flat_map do |field|
+        parts = field.split(":", -1)
+        next(field.empty? ? 0 : field.to_i) if parts.size == 1
+
+        code, mode = parts.values_at(0, 1).map(&:to_i)
+        if code == 4 && parts.size == 2 && parts.last.match?(/\A[0-5]\z/)
+          [[:underline_style, parts.last.to_i]]
+        elsif [38, 48, 58].include?(code) && mode == 2 && [5, 6].include?(parts.size) && parts.last(3).all? { |item| item.match?(/\A\d+\z/) }
+          [code, mode, *parts.last(3).map(&:to_i)]
+        elsif [38, 48, 58].include?(code) && mode == 5 && parts.size == 3 && parts.last.match?(/\A\d+\z/)
+          [code, mode, parts.last.to_i]
+        else
+          []
+        end
       end
     end
 
-    def color_256(index)
-      return nil unless index
-
-      if index < 16
-        standard_colors = %i[
-          black red green yellow blue magenta cyan white
-          bright_black bright_red bright_green bright_yellow
-          bright_blue bright_magenta bright_cyan bright_white
-        ]
-        standard_colors[index]
-      elsif index < 232
-        index -= 16
-        r = (index / 36) * 51
-        g = ((index % 36) / 6) * 51
-        b = (index % 6) * 51
-        format("#%02x%02x%02x", r, g, b)
-      else
-        gray = (index - 232) * 10 + 8
-        format("#%02x%02x%02x", gray, gray, gray)
-      end
+    def process_osc(value)
+      return unless value.to_s.start_with?("8;")
+
+      uri = value.to_s.split(";", 3)[2].to_s
+      @link = uri.empty? ? nil : safe_link(uri)
+    end
+
+    def safe_link(value)
+      return if value.bytesize > MAX_LINK_BYTES || value.match?(/[\x00-\x1f\x7f]/)
+
+      uri = URI.parse(value)
+      value if LINK_SCHEMES.include?(uri.scheme&.downcase)
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def split_incomplete_osc(value)
+      start = value.rindex("\e]")
+      return [value, +""] unless start
+
+      tail = value[start..]
+      return [value, +""] if tail.match?(OSC_REGEX)
+      return [value[0...start], tail] if tail.bytesize <= MAX_OSC_BYTES
+
+      [value[0...start], +""]
     end
+
   end
 end

data/lib/shellfie/cassette.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "errors"
+require_relative "output_writer"
+require_relative "session"
+
+module Shellfie
+  class Cassette
+    MAX_BYTES = 32 * 1_048_576
+    MAX_EVENTS = 10_000
+    TOP_LEVEL_KEYS = %i[version title columns rows events captures exit_status].freeze
+    EVENT_KEYS = %i[text delay visible status screen].freeze
+
+    def self.write(path, session)
+      OutputWriter.write(path, extension: "json") do |temporary_path|
+        json = JSON.pretty_generate(session.to_h)
+        raise ResourceLimitError, "Cassette is too large (max #{MAX_BYTES} bytes)" if json.bytesize > MAX_BYTES
+
+        File.write(temporary_path, json)
+      end
+    end
+
+    def self.read(path)
+      raise ParseError, "Cassette file not found: #{path}" unless File.file?(path)
+      content = File.open(path, "rb") { |file| file.read(MAX_BYTES + 1) }
+      raise ParseError, "Cassette is too large (max #{MAX_BYTES} bytes)" if content.bytesize > MAX_BYTES
+
+      raw = JSON.parse(content, symbolize_names: true)
+      validate!(raw)
+
+      Session.new(
+        columns: raw[:columns],
+        rows: raw[:rows],
+        title: raw[:title],
+        events: raw[:events] || [],
+        captures: raw[:captures] || {},
+        exit_status: raw[:exit_status]
+      )
+    rescue JSON::ParserError => e
+      raise ParseError, "Invalid cassette: #{e.message}"
+    end
+
+    def self.validate!(raw)
+      raise ParseError, "Cassette must be a JSON object" unless raw.is_a?(Hash)
+      raise ParseError, "Unsupported cassette version" unless raw[:version] == 1
+      raise ParseError, "Unknown cassette key" unless (raw.keys - TOP_LEVEL_KEYS).empty?
+      raise ParseError, "Cassette title must be a string" unless raw[:title].is_a?(String)
+      unless raw[:columns].is_a?(Integer) && raw[:columns].between?(1, 500) &&
+             raw[:rows].is_a?(Integer) && raw[:rows].between?(1, 200)
+        raise ParseError, "Invalid cassette dimensions"
+      end
+
+      events = raw[:events] || []
+      raise ParseError, "Cassette events must be an array" unless events.is_a?(Array)
+      raise ParseError, "Cassette has too many events" if events.size > MAX_EVENTS
+      events.each_with_index do |event, index|
+        unless event.is_a?(Hash) && (event.keys - EVENT_KEYS).empty? && event[:text].is_a?(String) &&
+               event[:delay].is_a?(Numeric) && event[:delay].finite? && event[:delay] >= 0 &&
+               [true, false].include?(event.fetch(:visible, true)) &&
+               (!event.key?(:screen) || event[:screen].is_a?(Array) && event[:screen].all?(String)) &&
+               (event[:status].nil? || event[:status].is_a?(Integer) && event[:status].between?(0, 255))
+          raise ParseError, "Invalid cassette event at index #{index}"
+        end
+      end
+
+      captures = raw[:captures] || {}
+      unless captures.is_a?(Hash) && captures.all? { |name, lines| name.is_a?(Symbol) && lines.is_a?(Array) && lines.all?(String) }
+        raise ParseError, "Cassette captures must map names to arrays of strings"
+      end
+      unless raw[:exit_status].nil? || raw[:exit_status].is_a?(Integer) && raw[:exit_status].between?(0, 255)
+        raise ParseError, "Invalid cassette exit status"
+      end
+    end
+  end
+end

data/lib/shellfie/cli.rb

@@ -2,13 +2,24 @@
 
 require "optparse"
 require_relative "../shellfie"
+require_relative "cli_generate"
+require_relative "cli_info"
+require_relative "cli_run"
+require_relative "cli_authoring"
+require_relative "dependency_checker"
+require_relative "transcript_renderer"
 
 module Shellfie
   class CLI
-    COMMANDS = %w[generate init themes validate version help].freeze
+    include CLIGenerate
+    include CLIInfo
+    include CLIRun
+    include CLIAuthoring
+
+    COMMANDS = %w[generate run record replay new format compile schema completion watch init themes validate inspect doctor version help].freeze
 
     def initialize(args)
-      @args = args
+      @args = args.dup
       @options = {}
     end
 
@@ -22,194 +33,91 @@ module Shellfie
         run_generate
       when "init"
         run_init
+      when "run"
+        run_session
+      when "record"
+        run_session(record: true)
+      when "replay"
+        replay_session
+      when "new"
+        run_new
+      when "format"
+        run_format
+      when "compile"
+        run_compile
+      when "schema"
+        run_schema
+      when "completion"
+        run_completion
+      when "watch"
+        run_watch
       when "themes"
         run_themes
       when "validate"
         run_validate
+      when "inspect"
+        run_inspect
+      when "doctor"
+        run_doctor
       when "version", "-v", "--version"
         run_version
       when "help", "-h", "--help"
         show_help
       else
-        puts "Unknown command: #{command}"
-        puts "Run 'shellfie help' for usage information."
+        warn_error "Unknown command: #{command}"
+        warn_error "Run 'shellfie help' for usage information."
         exit 1
       end
     rescue Shellfie::Error => e
-      puts "Error: #{e.message}"
+      if @options[:validation_format] && @options[:validation_format] != "text"
+        emit_validation_report(valid: false, error: e)
+      else
+        warn_error "Error: #{e.message}"
+      end
       exit determine_exit_code(e)
+    rescue OptionParser::ParseError => e
+      warn_error "Error: #{e.message}"
+      exit 1
+    rescue SystemCallError => e
+      warn_error "Error: #{e.message}"
+      exit 5
     end
 
     private
 
-    def run_generate
-      parser = OptionParser.new do |opts|
-        opts.banner = "Usage: shellfie generate INPUT_FILE [options]"
-
-        opts.on("-o", "--output PATH", "Output file path (required)") do |path|
-          @options[:output] = path
-        end
-
-        opts.on("-t", "--theme NAME", "Override theme (macos, ubuntu, windows)") do |theme|
-          @options[:theme] = theme
-        end
-
-        opts.on("-a", "--animate", "Generate animated GIF") do
-          @options[:animate] = true
-        end
-
-        opts.on("-s", "--scale FACTOR", "Output scale (1, 2, 3)") do |scale|
-          @options[:scale] = scale.to_i
-        end
-
-        opts.on("-w", "--width PIXELS", Integer, "Override width") do |width|
-          @options[:width] = width
-        end
-
-        opts.on("--no-shadow", "Disable shadow effect") do
-          @options[:shadow] = false
-        end
+    def canonical_output_path(path)
+      expanded = File.expand_path(path)
+      missing = []
+      current = expanded
+      until File.exist?(current)
+        parent = File.dirname(current)
+        break if parent == current
 
-        opts.on("--transparent", "Transparent background") do
-          @options[:transparent] = true
-        end
-
-        opts.on("--no-header", "Disable window header (headless mode)") do
-          @options[:headless] = true
-        end
-      end
-
-      parser.parse!(@args)
-
-      input_file = @args.shift
-      raise ConfigError, "Input file is required" unless input_file
-      raise ConfigError, "Output file is required (use -o option)" unless @options[:output]
-
-      config = Parser.parse(input_file)
-
-      if @options[:theme] || @options[:width] || @options[:headless]
-        config = Config.new(
-          theme: @options[:theme] || config.theme,
-          title: config.title,
-          window: config.window.merge(@options[:width] ? { width: @options[:width] } : {}),
-          font: config.font,
-          lines: config.lines,
-          animation: config.animation,
-          frames: config.frames,
-          headless: @options[:headless] || config.headless
-        )
+        missing.unshift(File.basename(current))
+        current = parent
       end
-
-      if @options[:animate] || config.animated?
-        generator = GifGenerator.new(config)
-        output = generator.generate(
-          @options[:output],
-          scale: @options[:scale] || 1,
-          shadow: @options[:shadow] != false
-        )
-      else
-        renderer = Renderer.new(config)
-        output = renderer.render(
-          @options[:output],
-          scale: @options[:scale] || 1,
-          shadow: @options[:shadow] != false,
-          transparent: @options[:transparent] || false
-        )
-      end
-
-      puts "Generated: #{output}"
-    end
-
-    def run_init
-      sample_config = <<~YAML
-        # Shellfie configuration file
-        theme: macos
-        title: "Terminal — zsh"
-
-        window:
-          width: 600
-          padding: 20
-
-        lines:
-          - prompt: "$ "
-            command: "gem install shellfie"
-
-          - output: |
-              Fetching shellfie-#{VERSION}.gem
-              Successfully installed shellfie-#{VERSION}
-              1 gem installed
-
-          - prompt: "$ "
-            command: "shellfie --version"
-
-          - output: "shellfie #{VERSION}"
-      YAML
-
-      puts sample_config
+      File.join(File.realpath(current), *missing)
+    rescue Errno::ENOENT
+      expanded
     end
 
-    def run_themes
-      puts "Available themes:"
-      puts
-      puts "  macos     - macOS Terminal style (red/yellow/green buttons, left side)"
-      puts "  ubuntu    - Ubuntu Terminal style (buttons on right side)"
-      puts "  windows   - Windows Terminal style (square corners, icons)"
-      puts
-      puts "Use: shellfie generate config.yml -o output.png -t THEME_NAME"
+    def configuration_version(path)
+      raw = YamlSafety.load_file(path, max_bytes: Parser::MAX_INCLUDE_BYTES)
+      raw.is_a?(Hash) ? raw[:version] : nil
     end
 
-    def run_validate
-      input_file = @args.shift
-      raise ConfigError, "Input file is required" unless input_file
-
-      config = Parser.parse(input_file)
-      puts "✓ Configuration is valid"
-      puts "  Theme: #{config.theme}"
-      puts "  Title: #{config.title}"
-      puts "  Lines: #{config.lines.size}"
-      puts "  Mode: #{config.animated? ? "animated" : "static"}"
+    def replaceable_png_sequence_directory?(path)
+      entries = Dir.children(path)
+      entries.empty? || (entries.include?("timeline.json") &&
+        entries.all? { |entry| entry == "timeline.json" || entry.match?(/\Aframe_\d{4}\.png\z/) })
     end
 
-    def run_version
-      puts "shellfie #{VERSION}"
+    def path_within?(path, directory)
+      path == directory || path.start_with?("#{directory}#{File::SEPARATOR}")
     end
 
-    def show_help
-      puts <<~HELP
-        Shellfie - Terminal screenshot-style image generator
-
-        Usage: shellfie <command> [options]
-               shf <command> [options]
-
-        Commands:
-          generate    Generate image from configuration file
-          init        Output sample configuration
-          themes      List available themes
-          validate    Validate configuration file
-          version     Show version
-          help        Show this help
-
-        Generate Options:
-          -o, --output PATH      Output file path (required)
-          -t, --theme NAME       Override theme (macos, ubuntu, windows)
-          -a, --animate          Generate animated GIF
-          -s, --scale FACTOR     Output scale (1, 2, 3)
-          -w, --width PIXELS     Override width
-          --no-shadow            Disable shadow effect
-          --no-header            Disable window header (headless mode)
-          --transparent          Transparent background
-
-        Examples:
-          shellfie generate config.yml -o terminal.png
-          shellfie generate config.yml -o demo.gif --animate
-          shellfie generate config.yml -o retina.png --scale 2
-          shellfie init > my-config.yml
-          shellfie themes
-
-          # Short form
-          shf generate config.yml -o terminal.png
-          shf init > config.yml
-      HELP
+    def warn_error(message)
+      $stderr.puts message
     end
 
     def determine_exit_code(error)
@@ -220,6 +128,10 @@ module Shellfie
         3
       when DependencyError
         4
+      when FileSystemError
+        5
+      when ExecutionError
+        6
       else
         1
       end