ruby_raider 2.0.0 → 3.0.0

data/lib/scaffolding/url_analyzer.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+
+class UrlAnalyzer
+  INTERACTIVE_TAGS = %w[input select textarea button].freeze
+
+  attr_reader :url, :page_name, :elements
+
+  def initialize(url, name_override: nil, ai: false) # rubocop:disable Naming/MethodParameterName
+    @url = url
+    @uri = URI.parse(url)
+    @page_name = name_override || derive_page_name
+    @elements = []
+    @ai = ai
+  end
+
+  def analyze
+    html = fetch_html
+    if @ai
+      ai_elements = analyze_with_llm(html)
+      @elements = ai_elements if ai_elements
+    end
+    parse_elements(html) if @elements.empty?
+    self
+  end
+
+  def to_h
+    { page_name: @page_name, url: @url, url_path: @uri.path, elements: @elements }
+  end
+
+  private
+
+  def fetch_html
+    response = Net::HTTP.get_response(@uri)
+    response.body
+  rescue StandardError => e
+    raise "Failed to fetch #{@url}: #{e.message}"
+  end
+
+  def parse_elements(html)
+    # Simple regex-based HTML parsing (no external dependency needed)
+    parse_inputs(html)
+    parse_selects(html)
+    parse_textareas(html)
+    parse_buttons(html)
+    parse_links(html)
+  end
+
+  def parse_inputs(html)
+    html.scan(/<input\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      next if %w[hidden submit].include?(attrs['type'])
+
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || attrs['placeholder'] || 'input',
+        type: :input,
+        input_type: attrs['type'] || 'text',
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_selects(html)
+    html.scan(/<select\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || 'select',
+        type: :select,
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_textareas(html)
+    html.scan(/<textarea\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || 'textarea',
+        type: :textarea,
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_buttons(html)
+    html.scan(%r{<button\s+([^>]*)>([^<]*)</button>}i).each do |match|
+      attrs = parse_attributes(match[0])
+      text = match[1].strip
+      @elements << build_element(
+        name: attrs['id'] || attrs['name'] || text.downcase.gsub(/\s+/, '_') || 'button',
+        type: :button,
+        text:,
+        locator: best_locator(attrs, text:)
+      )
+    end
+
+    html.scan(/<input\s+([^>]*type=["']submit["'][^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['id'] || attrs['name'] || attrs['value']&.downcase&.gsub(/\s+/, '_') || 'submit',
+        type: :submit,
+        text: attrs['value'] || 'Submit',
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_links(html)
+    html.scan(%r{<a\s+([^>]*)>([^<]*)</a>}i).first(5)&.each do |match|
+      attrs = parse_attributes(match[0])
+      text = match[1].strip
+      next if text.empty?
+
+      @elements << build_element(
+        name: text.downcase.gsub(/\s+/, '_'),
+        type: :link,
+        text:,
+        locator: best_locator(attrs, text:)
+      )
+    end
+  end
+
+  def parse_attributes(attr_string)
+    attrs = {}
+    attr_string.scan(/([\w-]+)=["']([^"']*)["']/).each do |key, value|
+      attrs[key] = value
+    end
+    attrs
+  end
+
+  def best_locator(attrs, text: nil)
+    if attrs['id']
+      { type: :id, value: attrs['id'] }
+    elsif attrs['name']
+      { type: :name, value: attrs['name'] }
+    elsif attrs['class'] && !attrs['class'].empty?
+      { type: :css, value: ".#{attrs['class'].split.first}" }
+    elsif text && !text.empty?
+      { type: :xpath, value: "//#{infer_tag(attrs)}[contains(text(), '#{text}')]" }
+    else
+      { type: :css, value: attrs.first&.last || 'unknown' }
+    end
+  end
+
+  def infer_tag(attrs)
+    return 'button' if attrs['type'] == 'button' || attrs['type'] == 'submit'
+    return 'a' if attrs['href']
+
+    '*'
+  end
+
+  def build_element(name:, type:, locator:, **extra)
+    clean_name = name.to_s.gsub(/[^a-z0-9_]/i, '_').gsub(/_+/, '_').downcase.delete_prefix('_').delete_suffix('_')
+    { name: clean_name, type:, locator: }.merge(extra)
+  end
+
+  def analyze_with_llm(html)
+    require_relative '../llm/client'
+    require_relative '../llm/prompts'
+    require_relative '../llm/response_parser'
+
+    return nil unless Llm::Client.available?
+
+    response = Llm::Client.complete(
+      Llm::Prompts.analyze_page(html, @url),
+      system_prompt: Llm::Prompts.system_prompt
+    )
+    Llm::ResponseParser.extract_elements(response)
+  end
+
+  def derive_page_name
+    path = @uri.path.to_s.gsub(%r{^/|/$}, '')
+    return 'home' if path.empty?
+
+    path.split('/').last.gsub(/[^a-z0-9]/i, '_').downcase
+  end
+end

data/lib/utilities/desktop_downloader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'rbconfig'
+
+# Downloads the latest Raider Desktop release for the current platform.
+# Uses the GitHub API to discover the latest release and match the right artifact.
+module DesktopDownloader
+  REPO = 'RaiderHQ/raider_desktop'
+  API_URL = "https://api.github.com/repos/#{REPO}/releases/latest".freeze
+
+  PLATFORM_PATTERNS = {
+    'mac_arm' => /\.dmg$/i,
+    'mac_intel' => /\.dmg$/i,
+    'windows' => /setup\.exe$/i,
+    'linux_deb' => /\.deb$/i,
+    'linux_appimage' => /\.AppImage$/i
+  }.freeze
+
+  HTTP_OPEN_TIMEOUT = 10
+  HTTP_READ_TIMEOUT = 15
+
+  class << self
+    def download(destination_dir = nil)
+      destination_dir ||= default_download_dir
+      asset = find_asset
+      unless asset
+        warn '[Ruby Raider] No desktop release found for your platform'
+        return nil
+      end
+
+      destination = File.join(destination_dir, asset[:name])
+      puts "Downloading Raider Desktop (#{asset[:name]})..."
+      download_file(asset[:url], destination)
+      puts "Downloaded to: #{destination}"
+      destination
+    end
+
+    def latest_version
+      cached_release&.dig('tag_name')
+    end
+
+    def download_url
+      asset = find_asset
+      asset&.dig(:url)
+    end
+
+    # Clear cached release data (useful between operations or for testing)
+    def clear_cache
+      @cached_release = :unset
+    end
+
+    def platform
+      host_os = RbConfig::CONFIG['host_os']
+      arch = RbConfig::CONFIG['host_cpu']
+
+      case host_os
+      when /darwin|mac os/i
+        arch =~ /arm|aarch64/i ? 'mac_arm' : 'mac_intel'
+      when /mswin|mingw|cygwin|windows/i
+        'windows'
+      when /linux/i
+        'linux_appimage'
+      else
+        'linux_appimage'
+      end
+    end
+
+    def platform_display_name
+      case platform
+      when 'mac_arm' then 'macOS (Apple Silicon)'
+      when 'mac_intel' then 'macOS (Intel)'
+      when 'windows' then 'Windows'
+      when 'linux_deb' then 'Linux (deb)'
+      when 'linux_appimage' then 'Linux (AppImage)'
+      else 'Unknown'
+      end
+    end
+
+    private
+
+    def find_asset
+      release = cached_release
+      return nil unless release
+
+      assets = release['assets'] || []
+      pattern = PLATFORM_PATTERNS[platform]
+      return nil unless pattern
+
+      matched = assets.find { |a| a['name'].match?(pattern) }
+      return nil unless matched
+
+      { name: matched['name'], url: matched['browser_download_url'], size: matched['size'] }
+    end
+
+    # Cache release data to avoid duplicate GitHub API calls
+    # (latest_version, find_asset, and download_url all need the same data)
+    def cached_release
+      return @cached_release if defined?(@cached_release) && @cached_release != :unset
+
+      @cached_release = fetch_latest_release
+    end
+
+    def fetch_latest_release
+      uri = URI(API_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = HTTP_OPEN_TIMEOUT
+      http.read_timeout = HTTP_READ_TIMEOUT
+      response = http.get(uri.request_uri)
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      warn "[Ruby Raider] GitHub API timed out: #{e.message}"
+      nil
+    rescue StandardError => e
+      warn "[Ruby Raider] Failed to check releases: #{e.message}"
+      nil
+    end
+
+    def download_file(url, destination)
+      FileUtils.mkdir_p(File.dirname(destination))
+      uri = URI(url)
+      follow_redirects(uri, destination)
+    end
+
+    def follow_redirects(uri, destination, limit = 5)
+      raise 'Too many redirects' if limit.zero?
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https',
+                                          open_timeout: HTTP_OPEN_TIMEOUT, read_timeout: 60) do |http|
+        request = Net::HTTP::Get.new(uri)
+        http.request(request) do |response|
+          case response
+          when Net::HTTPRedirection
+            follow_redirects(URI(response['location']), destination, limit - 1)
+          when Net::HTTPSuccess
+            write_response(response, destination)
+          else
+            raise "Download failed: #{response.code} #{response.message}"
+          end
+        end
+      end
+    end
+
+    def write_response(response, destination)
+      total = response['content-length']&.to_i
+      downloaded = 0
+      File.open(destination, 'wb') do |file|
+        response.read_body do |chunk|
+          file.write(chunk)
+          downloaded += chunk.size
+          print_progress(downloaded, total) if total&.positive?
+        end
+      end
+      puts
+    end
+
+    def print_progress(downloaded, total)
+      percent = (downloaded * 100.0 / total).round(1)
+      bar_width = 30
+      filled = (percent / 100.0 * bar_width).round
+      bar = "#{'=' * filled}#{' ' * (bar_width - filled)}"
+      mb = (downloaded / 1_048_576.0).round(1)
+      total_mb = (total / 1_048_576.0).round(1)
+      print "\r  [#{bar}] #{percent}% (#{mb}/#{total_mb} MB)"
+    end
+
+    def default_download_dir
+      downloads = File.expand_path('~/Downloads')
+      File.directory?(downloads) ? downloads : Dir.pwd
+    end
+  end
+end

data/lib/utilities/logo.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubyRaider
+  # Displays the Ruby Raider logo as colored pixel art in the terminal.
+  # Renders a faceted gem icon alongside "RUBY RAIDER" in a pixel font,
+  # using Unicode half-block characters for compact, high-detail output.
+  module Logo
+    # Color palette: 0 = empty, 1 = dark, 2 = medium, 3 = bright
+    PALETTE = {
+      1 => '130;30;48',
+      2 => '180;45;65',
+      3 => '230;70;90'
+    }.freeze
+
+    # Gem diamond with faceted shading (6 pixel rows × 9 cols)
+    GEM = [
+      [0, 0, 0, 3, 3, 3, 0, 0, 0],
+      [0, 2, 3, 3, 3, 3, 3, 2, 0],
+      [2, 3, 2, 3, 3, 3, 2, 3, 2],
+      [2, 2, 1, 2, 2, 2, 1, 2, 2],
+      [0, 1, 2, 1, 1, 1, 2, 1, 0],
+      [0, 0, 0, 1, 1, 1, 0, 0, 0]
+    ].freeze
+
+    # 5-row pixel font glyphs
+    GLYPHS = {
+      'R' => [[1, 1, 1, 0], [1, 0, 0, 1], [1, 1, 1, 0], [1, 0, 1, 0], [1, 0, 0, 1]],
+      'U' => [[1, 0, 0, 1], [1, 0, 0, 1], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]],
+      'B' => [[1, 1, 1, 0], [1, 0, 0, 1], [1, 1, 1, 0], [1, 0, 0, 1], [1, 1, 1, 0]],
+      'Y' => [[1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0]],
+      ' ' => [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]],
+      'A' => [[0, 1, 1, 0], [1, 0, 0, 1], [1, 1, 1, 1], [1, 0, 0, 1], [1, 0, 0, 1]],
+      'I' => [[1, 1, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 1, 1]],
+      'D' => [[1, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [1, 0, 0, 1], [1, 1, 1, 0]],
+      'E' => [[1, 1, 1, 1], [1, 0, 0, 0], [1, 1, 1, 0], [1, 0, 0, 0], [1, 1, 1, 1]]
+    }.freeze
+
+    TEXT_COLOR = 3
+
+    def self.display
+      text_rows = build_text('RUBY RAIDER')
+      text_width = text_rows.first.length
+
+      # Build 6-row text grid: blank top row centers text vertically with gem
+      text_grid = [Array.new(text_width, 0)]
+      text_rows.each { |row| text_grid << row.map { |px| px == 1 ? TEXT_COLOR : 0 } }
+
+      # Compose: gem(9) + gap(2) + text
+      grid = 6.times.map { |y| GEM[y] + [0, 0] + text_grid[y] }
+
+      # Render 3 terminal rows (each encodes 2 pixel rows via half-blocks)
+      3.times do |tr|
+        line = +''
+        top = grid[tr * 2]
+        bot = grid[tr * 2 + 1]
+        top.length.times { |x| line << halfblock(top[x], bot[x]) }
+        puts "  #{line.rstrip}"
+      end
+      puts
+    end
+
+    def self.halfblock(top, bot)
+      return ' ' if top.zero? && bot.zero?
+      return "\e[38;2;#{PALETTE[top]}m█\e[0m" if top == bot
+      return "\e[38;2;#{PALETTE[bot]}m▄\e[0m" if top.zero?
+      return "\e[38;2;#{PALETTE[top]}m▀\e[0m" if bot.zero?
+
+      "\e[38;2;#{PALETTE[top]};48;2;#{PALETTE[bot]}m▀\e[0m"
+    end
+
+    def self.build_text(str)
+      rows = Array.new(5) { [] }
+      str.each_char.with_index do |ch, i|
+        glyph = GLYPHS.fetch(ch.upcase, GLYPHS[' '])
+        5.times { |r| rows[r].push(0, 0) } if i.positive?
+        5.times { |r| rows[r].concat(glyph[r]) }
+      end
+      rows
+    end
+
+    private_class_method :halfblock, :build_text
+  end
+end

data/lib/utilities/utilities.rb

@@ -7,46 +7,44 @@ module Utilities
 
   class << self
     def browser=(browser)
-      config['browser'] = browser
-      overwrite_yaml
+      set('browser', browser)
     end
 
     def page_path=(path)
-      config['page_path'] = path
-      overwrite_yaml
+      set('page_path', path)
     end
 
     def spec_path=(path)
-      config['spec_path'] = path
-      overwrite_yaml
+      set('spec_path', path)
     end
 
     def feature_path=(path)
-      config['feature_path'] = path
-      overwrite_yaml
+      set('feature_path', path)
     end
 
     def helper_path=(path)
-      config['helper_path'] = path
-      overwrite_yaml
+      set('helper_path', path)
     end
 
     def url=(url)
-      config['url'] = url
-      overwrite_yaml
+      set('url', url)
+    end
+
+    def timeout=(seconds)
+      set('timeout', seconds.to_i)
+    end
+
+    def viewport=(dimensions)
+      width, height = dimensions.split('x').map(&:to_i)
+      set('viewport', { 'width' => width, 'height' => height })
     end
 
     def platform=(platform)
-      config['platform'] = platform
-      overwrite_yaml
+      set('platform', platform)
     end
 
-    def browser_options=(*opts)
-      args = opts.flatten
-      browser_args = config['browser_arguments']
-      browser = args.first&.to_sym
-      browser_args[browser] = browser_args[browser] + args[1..] if browser_args.key?(browser)
-      overwrite_yaml
+    def browser_options=(opts)
+      set('browser_options', Array(opts).flatten)
     end
 
     def delete_browser_options
@@ -54,6 +52,35 @@ module Utilities
       overwrite_yaml
     end
 
+    def llm_provider=(provider)
+      set('llm_provider', provider)
+    end
+
+    def llm_api_key=(key)
+      set('llm_api_key', key)
+    end
+
+    def llm_model=(model)
+      set('llm_model', model)
+    end
+
+    def llm_url=(url)
+      set('llm_url', url)
+    end
+
+    def debug=(enabled)
+      config['debug'] ||= {}
+      config['debug']['enabled'] = enabled
+      overwrite_yaml
+    end
+
+    # Set multiple config keys in a single YAML write.
+    # Usage: Utilities.batch_update(browser: 'chrome', timeout: 30)
+    def batch_update(**settings)
+      settings.each { |key, value| config[key.to_s] = value }
+      overwrite_yaml
+    end
+
     def run(opts = nil)
       command = File.directory?('spec') ? 'rspec spec/' : 'cucumber features'
       system "#{command} #{opts}"
@@ -66,6 +93,12 @@ module Utilities
 
     private
 
+    # Single-key setter: updates in-memory config and writes once
+    def set(key, value)
+      config[key] = value
+      overwrite_yaml
+    end
+
     def overwrite_yaml
       File.open(@path, 'w') { |file| YAML.dump(config, file) }
     end

data/lib/version

@@ -1 +1 @@
-2.0.0
+3.0.0

data/ruby_raider.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rubocop', '~> 1.27'
   s.add_development_dependency 'rubocop-performance', '~> 1.15.0'
   s.add_development_dependency 'rubocop-rspec', '~> 2.9.0'
+  s.add_development_dependency 'steep', '~> 1.9'
 
   s.add_runtime_dependency 'thor', '~> 1.2.1'
   s.add_runtime_dependency 'tty-prompt', '~> 0.23.1'

data/sig/adopter/adopt_menu.rbs

@@ -0,0 +1,25 @@
+# Type definitions for Adopter::AdoptMenu
+module Adopter
+  class AdoptMenu
+    WEB_AUTOMATIONS: Array[String]
+    TEST_FRAMEWORKS: Array[String]
+    CI_PLATFORMS: Array[String]
+
+    def initialize: () -> void
+    def run: () -> void
+
+    def self.adopt: (Hash[Symbol, untyped] params) -> Hash[Symbol, untyped]
+    def self.validate_params!: (Hash[Symbol, untyped] params) -> void
+
+    private
+
+    def ask_source_path: () -> String
+    def preview_detection: (String source_path) -> Hash[Symbol, untyped]
+    def ask_target_automation: (String? detected) -> String
+    def ask_target_framework: (String? detected) -> String
+    def ask_output_path: () -> String?
+    def ask_ci_platform: (String? detected) -> String?
+    def execute_adoption: (Hash[Symbol, untyped] params) -> void
+    def print_results: (MigrationPlan plan, Hash[Symbol, untyped] results) -> void
+  end
+end

data/sig/adopter/converters/base_converter.rbs

@@ -0,0 +1,23 @@
+# Type definitions for Adopter::Converters::BaseConverter
+module Adopter
+  module Converters
+    class BaseConverter
+      RAIDER_BASE_CLASSES: Array[String]
+
+      def convert_page: (String content, untyped _page_info) -> String
+      def convert_test: (String content, untyped _test_info) -> String
+
+      private
+
+      def ensure_frozen_string_literal: (String content) -> String
+      def update_base_class: (String content, String target_base) -> String
+      def raider_compatible_base?: (String base_class) -> bool
+      def update_require_paths: (String content, String target_automation) -> String
+      def update_page_requires: (String content) -> String
+      def update_helper_requires: (String content, String target_automation) -> String
+      def remove_driver_arg: (String content) -> String
+      def swap_driver_arg: (String content, String target_arg) -> String
+      def driver_arg_for: (String target_automation) -> String?
+    end
+  end
+end

data/sig/adopter/converters/identity_converter.rbs

@@ -0,0 +1,16 @@
+# Type definitions for Adopter::Converters::IdentityConverter
+module Adopter
+  module Converters
+    class IdentityConverter < BaseConverter
+      def initialize: (String target_automation) -> void
+      def convert_page: (String content, untyped _page_info) -> String
+      def convert_test: (String content, untyped _test_info) -> String
+      def convert_step: (String content) -> String
+
+      private
+
+      def add_page_require: (String content) -> String
+      def update_page_instantiation: (String content) -> String
+    end
+  end
+end

data/sig/adopter/migration_plan.rbs

@@ -0,0 +1,34 @@
+# Type definitions for Adopter::MigrationPlan and ConvertedFile
+module Adopter
+  class MigrationPlan
+    attr_reader source_path: String
+    attr_reader output_path: String
+    attr_reader target_automation: String
+    attr_reader target_framework: String
+    attr_reader ci_platform: String?
+    attr_reader skeleton_structure: Hash[Symbol, untyped]
+    attr_reader converted_pages: Array[ConvertedFile]
+    attr_reader converted_tests: Array[ConvertedFile]
+    attr_reader converted_features: Array[ConvertedFile]
+    attr_reader converted_steps: Array[ConvertedFile]
+    attr_reader gemfile_additions: Array[String]
+    attr_reader config_overrides: Hash[String, untyped]
+    attr_reader warnings: Array[String]
+    attr_reader manual_actions: Array[String]
+
+    def initialize: (?Hash[Symbol, untyped]? attrs) -> void
+    def to_h: () -> Hash[Symbol, untyped]
+    def to_json: (*untyped args) -> String
+    def summary: () -> Hash[Symbol, untyped]
+  end
+
+  class ConvertedFile
+    attr_accessor output_path: String
+    attr_accessor content: String
+    attr_accessor source_file: String?
+    attr_accessor conversion_notes: String?
+
+    def initialize: (?output_path: String, ?content: String, ?source_file: String?, ?conversion_notes: String?) -> void
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/adopter/migrator.rbs

@@ -0,0 +1,21 @@
+# Type definitions for Adopter::Migrator
+module Adopter
+  class Migrator
+    attr_reader plan: MigrationPlan
+    attr_reader results: Hash[Symbol, untyped]
+
+    def initialize: (MigrationPlan plan) -> void
+    def execute: () -> Hash[Symbol, untyped]
+
+    private
+
+    def generate_skeleton: () -> void
+    def write_converted_pages: () -> void
+    def write_converted_tests: () -> void
+    def write_converted_features: () -> void
+    def write_converted_steps: () -> void
+    def write_file: (ConvertedFile converted_file) -> void
+    def merge_gemfile: () -> void
+    def apply_config_overrides: () -> void
+  end
+end