ruby_raider 3.0.1 → 3.2.0

data/lib/generators/templates/helpers/debug_helper.tt

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'yaml'
-require 'logger'
-require 'json'
-
-module DebugHelper
-  LOG_DIR = 'debug_logs'
-
-  module_function
-
-  # --- Configuration ---
-
-  def config
-    @config ||= begin
-      yml = YAML.load_file('config/config.yml')
-      yml['debug'] || {}
-    rescue StandardError
-      {}
-    end
-  end
-
-  def enabled?
-    ENV['DEBUG']&.downcase == 'true' || config.fetch('enabled', false)
-  end
-
-  def console_logs?
-    enabled? && config.fetch('console_logs', true)
-  end
-
-  def action_logging?
-    enabled? && config.fetch('action_logging', true)
-  end
-
-  def network_logging?
-    enabled? && config.fetch('network_logging', true)
-  end
-
-  def log_dir
-    config.fetch('log_dir', LOG_DIR)
-  end
-
-  def ensure_log_dir
-    FileUtils.mkdir_p(log_dir)
-  end
-
-  # --- Driver Resolution ---
-
-  def resolve_selenium_driver(obj)
-    if obj.respond_to?(:driver) && !obj.is_a?(Selenium::WebDriver::Driver)
-      obj.driver
-    elsif obj.respond_to?(:browser) && obj.browser.respond_to?(:driver)
-      obj.browser.driver
-    else
-      obj
-    end
-  rescue StandardError
-    obj
-  end
-
-  # --- Failure Diagnostics (returns structured hash for desktop integration) ---
-
-  def capture_failure_diagnostics(driver_or_browser, test_name, exception: nil)
-    return {} unless enabled?
-
-    ensure_log_dir
-    sel_driver = resolve_selenium_driver(driver_or_browser)
-    safe_name = sanitize(test_name)
-    diagnostics = { test_name: test_name, timestamp: Time.now.iso8601 }
-
-    diagnostics[:url] = sel_driver.current_url rescue 'unknown'
-    diagnostics[:title] = sel_driver.title rescue 'unknown'
-
-    if exception
-      diagnostics[:error_message] = exception.message
-      diagnostics[:error_class] = exception.class.name
-      diagnostics[:stack_trace] = exception.backtrace&.first(20) || []
-    end
-
-    diagnostics[:console_logs] = capture_console_logs(sel_driver) if console_logs?
-    diagnostics[:network_log_path] = capture_network_logs(sel_driver, safe_name) if network_logging?
-
-    # HTML snapshot
-    html_path = File.join(log_dir, "#{safe_name}_page.html")
-    File.write(html_path, sel_driver.page_source) rescue nil
-    diagnostics[:html_snapshot] = html_path
-
-    # Write diagnostics JSON (desktop app reads this)
-    summary_path = File.join(log_dir, "#{safe_name}_diagnostics.json")
-    File.write(summary_path, JSON.pretty_generate(diagnostics))
-    diagnostics[:summary_path] = summary_path
-
-    diagnostics
-  rescue StandardError => e
-    warn "[debug] Failed to capture diagnostics: #{e.message}"
-    {}
-  end
-
-  # --- Console Log Capture ---
-
-  def capture_console_logs(sel_driver)
-    return [] unless chrome_or_edge?(sel_driver)
-
-    sel_driver.logs.get(:browser).map { |entry| { level: entry.level, message: entry.message, timestamp: entry.timestamp } }
-  rescue StandardError
-    []
-  end
-
-  # --- Action Logger ---
-
-  class ActionLogger
-    def initialize(test_name)
-      DebugHelper.ensure_log_dir
-      log_path = File.join(DebugHelper.log_dir, "#{DebugHelper.sanitize(test_name)}_actions.log")
-      @logger = Logger.new(log_path)
-      @logger.formatter = proc { |severity, datetime, _progname, msg|
-        "[#{datetime.strftime('%H:%M:%S.%L')}] #{severity}: #{msg}\n"
-      }
-    end
-
-    def log(action, details = '')
-      @logger.info("#{action} #{details}".strip)
-    end
-
-    def close
-      @logger.close
-    rescue StandardError
-      nil
-    end
-  end
-
-  class NullActionLogger
-    def log(_action, _details = '') = nil
-    def close = nil
-  end
-
-  def action_logger_for(test_name)
-    action_logging? ? ActionLogger.new(test_name) : NullActionLogger.new
-  end
-
-  # --- Network Logging Setup ---
-
-  def enable_network_logging(driver_or_browser)
-    return unless network_logging?
-
-    sel_driver = resolve_selenium_driver(driver_or_browser)
-    return unless chrome_or_edge?(sel_driver)
-
-    sel_driver.execute_cdp('Network.enable')
-  rescue StandardError => e
-    warn "[debug] Could not enable network logging: #{e.message}"
-  end
-
-  # --- Network Log Capture ---
-
-  def capture_network_logs(sel_driver, safe_name)
-    return unless chrome_or_edge?(sel_driver)
-
-    logs = sel_driver.logs.get(:performance)
-    return if logs.empty?
-
-    entries = logs.filter_map do |entry|
-      parsed = JSON.parse(entry.message)['message'] rescue next
-      parsed if parsed.is_a?(Hash) && parsed['method']&.start_with?('Network.')
-    end
-
-    return if entries.empty?
-
-    network_path = File.join(log_dir, "#{safe_name}_network.json")
-    File.write(network_path, JSON.pretty_generate(entries))
-    network_path
-  rescue StandardError => e
-    warn "[debug] Failed to capture network logs: #{e.message}"
-    nil
-  end
-
-  # --- Helpers ---
-
-  def chrome_or_edge?(driver)
-    browser_name = driver.capabilities[:browser_name].to_s.downcase
-    %w[chrome chromium msedge edge].any? { |b| browser_name.include?(b) }
-  rescue StandardError
-    false
-  end
-
-  def sanitize(name)
-    name.to_s.gsub(/[^a-zA-Z0-9_-]/, '_')[0..80]
-  end
-end

data/lib/generators/templates/helpers/partials/debug_diagnostics.tt

@@ -1,7 +0,0 @@
-<% if capybara? %>
-  DebugHelper.capture_failure_diagnostics(Capybara.current_session.driver, example_name, exception: @_exception)
-<% elsif selenium_based? %>
-  DebugHelper.capture_failure_diagnostics(driver, example_name, exception: @_exception)
-<% elsif watir? %>
-  DebugHelper.capture_failure_diagnostics(browser, example_name, exception: @_exception)
-<% end %>

data/lib/generators/templates/helpers/partials/debug_start.tt

@@ -1,7 +0,0 @@
-<% if capybara? %>
-  DebugHelper.enable_network_logging(Capybara.current_session.driver)
-<% elsif selenium_based? %>
-  DebugHelper.enable_network_logging(driver)
-<% elsif watir? %>
-  DebugHelper.enable_network_logging(browser)
-<% end %>

data/lib/generators/templates/helpers/performance_helper.tt

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-require 'json'
-require 'fileutils'
-require 'yaml'
-
-module PerformanceHelper
-  REPORTS_DIR = 'lighthouse_reports'
-
-  def run_lighthouse_audit(url, categories: %w[performance accessibility best-practices seo])
-    FileUtils.mkdir_p(REPORTS_DIR)
-
-    report_path = File.join(REPORTS_DIR, "report_#{Time.now.to_i}.json")
-    category_flags = categories.map { |c| "--only-categories=#{c}" }.join(' ')
-
-    config_timeout = if File.exist?('config/config.yml')
-                        YAML.load_file('config/config.yml').fetch('timeout', 10)
-                      else
-                        10
-                      end
-    max_wait = config_timeout * 1000
-
-    command = "lighthouse #{url} --output=json --output-path=#{report_path} " \
-              "--chrome-flags=\"--headless --no-sandbox\" #{category_flags} " \
-              "--max-wait-for-load=#{max_wait} --quiet"
-
-    stdout, stderr, status = Open3.capture3(command)
-
-    unless status.success?
-      return { status: :error, message: "Lighthouse failed: #{stderr.strip.empty? ? stdout : stderr}" }
-    end
-
-    report = JSON.parse(File.read(report_path))
-    scores = extract_scores(report)
-
-    { status: :success, scores:, report_path: }
-  end
-
-  def assert_performance_above(url, threshold: 0.8, categories: %w[performance])
-    result = run_lighthouse_audit(url, categories:)
-    return result if result[:status] == :error
-
-    passed = result[:scores].all? { |_category, score| score >= threshold }
-
-    { status: passed ? :pass : :fail, scores: result[:scores], passed:, threshold:,
-      report_path: result[:report_path] }
-  end
-
-  private
-
-  def extract_scores(report)
-    report.fetch('categories', {}).each_with_object({}) do |(key, data), scores|
-      scores[key] = data['score']
-    end
-  end
-end

data/lib/generators/templates/helpers/visual_helper.tt

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'chunky_png'
-require 'fileutils'
-
-module VisualHelper
-  BASELINE_DIR = 'visual_baselines'
-  DIFF_DIR = 'visual_diffs'
-
-  def compare_screenshot(name, screenshot_path, threshold: 0.01)
-    FileUtils.mkdir_p(BASELINE_DIR)
-    FileUtils.mkdir_p(DIFF_DIR)
-
-    baseline_path = File.join(BASELINE_DIR, "#{name}.png")
-
-    unless File.exist?(baseline_path)
-      FileUtils.cp(screenshot_path, baseline_path)
-      return { status: :baseline_created, path: baseline_path }
-    end
-
-    baseline = ChunkyPNG::Image.from_file(baseline_path)
-    current = ChunkyPNG::Image.from_file(screenshot_path)
-
-    diff_pixels = 0
-    total_pixels = baseline.width * baseline.height
-
-    diff_image = ChunkyPNG::Image.new(baseline.width, baseline.height)
-
-    baseline.height.times do |y|
-      baseline.width.times do |x|
-        if pixel_match?(baseline[x, y], current[x, y])
-          diff_image[x, y] = ChunkyPNG::Color.rgba(0, 0, 0, 50)
-        else
-          diff_pixels += 1
-          diff_image[x, y] = ChunkyPNG::Color.rgb(255, 0, 0)
-        end
-      end
-    end
-
-    diff_percentage = diff_pixels.to_f / total_pixels
-
-    if diff_percentage > threshold
-      diff_path = File.join(DIFF_DIR, "#{name}_diff.png")
-      diff_image.save(diff_path)
-      { status: :mismatch, diff: diff_percentage, diff_path: }
-    else
-      { status: :match, diff: diff_percentage }
-    end
-  end
-
-  private
-
-  def pixel_match?(pixel1, pixel2)
-    r1, g1, b1 = ChunkyPNG::Color.r(pixel1), ChunkyPNG::Color.g(pixel1), ChunkyPNG::Color.b(pixel1)
-    r2, g2, b2 = ChunkyPNG::Color.r(pixel2), ChunkyPNG::Color.g(pixel2), ChunkyPNG::Color.b(pixel2)
-    (r1 - r2).abs <= 5 && (g1 - g2).abs <= 5 && (b1 - b2).abs <= 5
-  end
-end

data/lib/llm/client.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require_relative 'config'
-
-module Llm
-  # Facade for LLM completion with retry logic and graceful fallback.
-  # Returns nil on any failure — callers should always have a non-AI fallback.
-  module Client
-    MAX_RETRIES = 3
-    BASE_DELAY = 1
-
-    # Only retry on transient network errors, not configuration or API errors
-    RETRYABLE_ERRORS = [
-      Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED,
-      Errno::ECONNRESET, Errno::ETIMEDOUT, SocketError
-    ].freeze
-
-    class << self
-      def complete(prompt, system_prompt: nil)
-        provider = build_provider
-        return nil unless provider
-
-        attempt = 0
-        begin
-          attempt += 1
-          provider.complete(prompt, system_prompt:)
-        rescue *RETRYABLE_ERRORS => e
-          if attempt < MAX_RETRIES
-            sleep(BASE_DELAY * (2**(attempt - 1)))
-            retry
-          end
-          warn "[Ruby Raider] LLM failed after #{MAX_RETRIES} attempts: #{e.message}"
-          nil
-        rescue StandardError => e
-          warn "[Ruby Raider] LLM error: #{e.message}"
-          nil
-        end
-      end
-
-      def available?
-        config = Config.new
-        return false unless config.configured?
-
-        provider = config.build_provider
-        provider&.available? || false
-      end
-
-      def status
-        config = Config.new
-        return { configured: false, provider: nil } unless config.configured?
-
-        provider = config.build_provider
-        {
-          configured: true,
-          provider: config.provider_name,
-          model: config.model,
-          available: provider&.available? || false
-        }
-      end
-
-      private
-
-      def build_provider
-        config = Config.new
-        unless config.configured?
-          warn '[Ruby Raider] No LLM configured. Use: raider u llm ollama'
-          return nil
-        end
-        provider = config.build_provider
-        unless provider&.available?
-          warn "[Ruby Raider] LLM provider '#{config.provider_name}' is not available"
-          return nil
-        end
-        provider
-      end
-    end
-  end
-end

data/lib/llm/config.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module Llm
-  # Reads LLM configuration from env vars and config/config.yml
-  # Env vars take precedence over config file values.
-  class Config
-    PROVIDERS = %w[openai anthropic ollama].freeze
-
-    attr_reader :provider_name, :api_key, :model, :url
-
-    def initialize
-      @provider_name = env('RUBY_RAIDER_LLM_PROVIDER') || config_value('llm_provider')
-      @api_key = env('RUBY_RAIDER_LLM_API_KEY') || config_value('llm_api_key')
-      @model = env('RUBY_RAIDER_LLM_MODEL') || config_value('llm_model')
-      @url = env('RUBY_RAIDER_LLM_URL') || config_value('llm_url')
-    end
-
-    def configured?
-      return false unless @provider_name && PROVIDERS.include?(@provider_name)
-      return true if @provider_name == 'ollama'
-
-      !@api_key.nil? && !@api_key.empty?
-    end
-
-    def build_provider
-      return nil unless configured?
-
-      case @provider_name
-      when 'openai'
-        require_relative 'providers/openai_provider'
-        Providers::OpenaiProvider.new(api_key: @api_key, model: @model)
-      when 'anthropic'
-        require_relative 'providers/anthropic_provider'
-        Providers::AnthropicProvider.new(api_key: @api_key, model: @model)
-      when 'ollama'
-        require_relative 'providers/ollama_provider'
-        Providers::OllamaProvider.new(model: @model, url: @url)
-      end
-    end
-
-    private
-
-    def env(key)
-      value = ENV.fetch(key, nil)
-      value&.strip&.empty? ? nil : value&.strip
-    end
-
-    def config_value(key)
-      return nil unless File.exist?('config/config.yml')
-
-      data = YAML.load_file('config/config.yml')
-      data&.dig(key)
-    end
-  end
-end

data/lib/llm/prompts.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Llm
-  # Centralized prompt templates for LLM-enhanced code generation.
-  # All prompts instruct the model to return JSON matching specific schemas.
-  module Prompts
-    module_function
-
-    def analyze_page(html, url)
-      <<~PROMPT
-        Analyze this HTML page and extract all interactive elements that would be useful for a page object model in UI test automation.
-
-        URL: #{url}
-
-        HTML:
-        #{html[0..8000]}
-
-        Return a JSON object with this exact structure:
-        {
-          "elements": [
-            {
-              "name": "descriptive_snake_case_name",
-              "type": "input|select|textarea|button|submit|link",
-              "locator": {"type": "id|name|css|xpath", "value": "the_locator"},
-              "purpose": "brief description of what this element does",
-              "input_type": "text|email|password|etc (only for inputs)",
-              "text": "visible text (only for buttons/links)"
-            }
-          ]
-        }
-
-        Guidelines:
-        - Use semantic, descriptive names (e.g., "email_field" not "input_1", "submit_login" not "button_1")
-        - Prefer ID locators, then name, then CSS, then XPath
-        - Skip hidden inputs and purely decorative elements
-        - Include up to 5 important links
-        - The "purpose" field should be a brief, clear description
-
-        Return ONLY the JSON object, no other text.
-      PROMPT
-    end
-
-    def generate_test_scenarios(class_name, methods, automation, framework)
-      methods_desc = methods.map do |m|
-        params = m[:params].empty? ? '' : "(#{m[:params].join(', ')})"
-        "  - #{m[:name]}#{params}"
-      end.join("\n")
-
-      <<~PROMPT
-        Generate meaningful test scenarios for this page object class used in UI test automation.
-
-        Class: #{class_name}
-        Automation: #{automation}
-        Framework: #{framework}
-        Public methods:
-        #{methods_desc}
-
-        Return a JSON object with this exact structure:
-        {
-          "scenarios": [
-            {
-              "method": "method_name",
-              "description": "human-readable test description",
-              "assertion_hint": "what to assert after calling this method"
-            }
-          ]
-        }
-
-        Guidelines:
-        - Generate one scenario per method
-        - Descriptions should read naturally (e.g., "fills in the login form with valid credentials")
-        - Assertion hints should be specific (e.g., "expect page to redirect to dashboard")
-        - Consider the class name for context about what page this is
-
-        Return ONLY the JSON object, no other text.
-      PROMPT
-    end
-
-    def system_prompt
-      'You are a UI test automation expert. You generate clean, idiomatic Ruby code ' \
-        'for page object models and test specs. Always return valid JSON when asked for JSON.'
-    end
-  end
-end

data/lib/llm/provider.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Llm
-  # Abstract base class for LLM providers
-  class Provider
-    def complete(prompt, system_prompt: nil)
-      raise NotImplementedError, "#{self.class}#complete must be implemented"
-    end
-
-    def available?
-      raise NotImplementedError, "#{self.class}#available? must be implemented"
-    end
-
-    def name
-      self.class.name.split('::').last.sub('Provider', '').downcase
-    end
-
-    private
-
-    def build_messages(prompt, system_prompt)
-      messages = []
-      messages << { role: 'system', content: system_prompt } if system_prompt
-      messages << { role: 'user', content: prompt }
-      messages
-    end
-  end
-end

data/lib/llm/providers/anthropic_provider.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../provider'
-
-module Llm
-  module Providers
-    class AnthropicProvider < Provider
-      DEFAULT_MODEL = 'claude-sonnet-4-20250514'
-
-      def initialize(api_key:, model: nil)
-        super()
-        @api_key = api_key
-        @model = model || DEFAULT_MODEL
-      end
-
-      def complete(prompt, system_prompt: nil)
-        client = build_client
-        params = { model: @model, max_tokens: 4096, messages: [{ role: 'user', content: prompt }] }
-        params[:system] = system_prompt if system_prompt
-        response = client.messages(parameters: params)
-        response.dig('content', 0, 'text')
-      rescue StandardError => e
-        warn "[Ruby Raider] Anthropic error: #{e.message}"
-        nil
-      end
-
-      def available?
-        require 'anthropic'
-        !@api_key.nil? && !@api_key.empty?
-      rescue LoadError
-        warn '[Ruby Raider] Install anthropic gem: gem install anthropic-rb'
-        false
-      end
-
-      private
-
-      def build_client
-        require 'anthropic'
-        Anthropic::Client.new(access_token: @api_key)
-      end
-    end
-  end
-end

data/lib/llm/providers/ollama_provider.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'json'
-require 'uri'
-require_relative '../provider'
-
-module Llm
-  module Providers
-    class OllamaProvider < Provider
-      DEFAULT_MODEL = 'llama3.2'
-      DEFAULT_URL = 'http://localhost:11434'
-      TIMEOUT = 60
-
-      def initialize(model: nil, url: nil)
-        super()
-        @model = model || DEFAULT_MODEL
-        @base_url = url || DEFAULT_URL
-      end
-
-      def complete(prompt, system_prompt: nil)
-        uri = URI("#{@base_url}/api/generate")
-        body = { model: @model, prompt:, stream: false }
-        body[:system] = system_prompt if system_prompt
-
-        response = post_request(uri, body)
-        return nil unless response.is_a?(Net::HTTPSuccess)
-
-        JSON.parse(response.body)['response']
-      rescue StandardError => e
-        warn "[Ruby Raider] Ollama error: #{e.message}"
-        nil
-      end
-
-      def available?
-        uri = URI("#{@base_url}/api/tags")
-        response = Net::HTTP.get_response(uri)
-        response.is_a?(Net::HTTPSuccess)
-      rescue StandardError
-        warn '[Ruby Raider] Ollama not reachable. Start it with: ollama serve'
-        false
-      end
-
-      private
-
-      def post_request(uri, body)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.read_timeout = TIMEOUT
-        http.open_timeout = 10
-        request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-        request.body = JSON.generate(body)
-        http.request(request)
-      end
-    end
-  end
-end