tng 0.1.4

data/lib/tng/api/http_client.rb

@@ -0,0 +1,102 @@
+require "httpx"
+
+module Tng
+  class HttpClient
+    def initialize(api_endpoint, api_key)
+      @api_endpoint = api_endpoint
+      @api_key = api_key
+      @timeout = {
+        connect_timeout: 300,
+        read_timeout: 300,
+        write_timeout: 300,
+        request_timeout: 300
+      }
+    end
+
+    def post(path, payload: {}, headers: {})
+      default_headers = {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+
+      merged_headers = default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).post(
+        "#{@api_endpoint}/#{path}",
+        json: payload,
+        headers: merged_headers
+      )
+
+      debug_response("POST #{path}", response) if debug_enabled?
+      response
+    end
+
+    def post_binary(path, data, headers: {})
+      default_headers = {
+        "Content-Type" => "application/octet-stream",
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+
+      merged_headers = default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).post(
+        "#{@api_endpoint}/#{path}",
+        body: data,
+        headers: merged_headers
+      )
+
+      debug_response("POST #{path} (binary)", response) if debug_enabled?
+      response
+    end
+
+    def get(path, headers: {})
+      default_headers = {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@api_key}",
+        "User-Agent" => "TestNG-Rails/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+
+      merged_headers = default_headers.merge(headers)
+
+      response = HTTPX.with(timeout: @timeout).get(
+        "#{@api_endpoint}/#{path}",
+        headers: merged_headers
+      )
+
+      debug_response("GET #{path}", response) if debug_enabled?
+      response
+    end
+
+    def ping
+      response = HTTPX.with(timeout: @timeout).get("#{@api_endpoint}/ping")
+      debug_response("GET /ping", response) if debug_enabled?
+      response
+    end
+
+    private
+
+    def debug_enabled?
+      ENV["DEBUG"] == "1"
+    end
+
+    def debug_response(request_info, response)
+      puts "\n -> DEBUG: #{request_info}"
+      puts "   Status: #{response.status}"
+      puts "   Headers: #{response.headers.to_h}"
+
+      if response.is_a?(HTTPX::ErrorResponse)
+        puts "   Error: #{response.error&.message}"
+      else
+        body = response.body.to_s
+        if body.length > 500
+          puts "   Body: #{body[0..500]}... (truncated, total length: #{body.length})"
+        else
+          puts "   Body: #{body}"
+        end
+      end
+      puts "   " + "─" * 50
+    end
+  end
+end

data/lib/tng/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Tng
+  class Railtie < Rails::Railtie
+    generators do
+      require_relative "../generators/tng/install_generator"
+    end
+  end
+end

data/lib/tng/services/test_generator.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "tng/utils"
+require "tng/services/user_app_config"
+
+module Tng
+  module Services
+    class TestGenerator
+      GENERATE_TESTS_PATH = "cli/tng_rails/contents/generate_tests"
+
+      def initialize(http_client)
+        @http_client = http_client
+        @machine_info = Tng.machine_info
+      end
+
+      def run_for_controller(controller)
+        payload = {
+          controller_test: Tng::Analyzers::Controller.read_test_file_for_controller(controller[:path]),
+          object_fixture_data: Tng::Utils.fixture_content,
+          machine_info: @machine_info,
+          ast: Tng::Analyzers::Controller.value_for_controller(controller[:path]),
+          test_type: "controller",
+          controller: controller,
+          routes: Tng::Analyzers::Controller.routes_for_controller(controller[:path]),
+          auth_patterns: Tng::Services::UserAppConfig.config_with_source,
+          model_info: Tng::Analyzers::Controller.model_info_for_controller(controller[:path]),
+          parents: Tng::Analyzers::Controller.parents_for_controller(controller)
+        }
+
+        send_request_and_save_test(payload)
+      end
+
+      def run_for_model(model)
+        payload = {
+          model_test: Tng::Analyzers::Model.read_test_file_for_model(model[:path]),
+          machine_info: @machine_info,
+          object_fixture_data: Tng::Utils.fixture_content,
+          ast: Tng::Analyzers::Model.value_for_model(model[:path]),
+          test_type: "model",
+          model: model,
+          auth_patterns: Tng::Services::UserAppConfig.config_with_source,
+          model_connections: Tng::Analyzers::Model.model_connections(model)
+        }
+
+        send_request_and_save_test(payload)
+      end
+
+      def run_for_service(service)
+        payload = {
+          service_test: Tng::Analyzers::Service.read_test_file_for_service(service[:path]),
+          machine_info: @machine_info,
+          object_fixture_data: Tng::Utils.fixture_content,
+          ast: Tng::Analyzers::Service.value_for_service(service[:path]),
+          test_type: "service",
+          service: service
+        }
+        send_request_and_save_test(payload)
+      end
+
+      def run_for_controller_method(controller, method_info)
+        payload = {
+          controller_test: Tng::Analyzers::Controller.read_test_file_for_controller(controller[:path]),
+          object_fixture_data: Tng::Utils.fixture_content,
+          machine_info: @machine_info,
+          ast: Tng::Analyzers::Controller.value_for_controller(controller[:path]),
+          test_type: "controller_method",
+          controller: controller,
+          method: method_info,
+          routes: Tng::Analyzers::Controller.routes_for_controller(controller[:path]),
+          auth_patterns: Tng::Services::UserAppConfig.config_with_source,
+          model_info: Tng::Analyzers::Controller.model_info_for_controller(controller[:path]),
+          parents: Tng::Analyzers::Controller.parents_for_controller(controller)
+        }
+
+        send_request_and_save_test(payload)
+      end
+
+      def run_for_model_method(model, method_info)
+        payload = {
+          model_test: Tng::Analyzers::Model.read_test_file_for_model(model[:path]),
+          machine_info: @machine_info,
+          object_fixture_data: Tng::Utils.fixture_content,
+          ast: Tng::Analyzers::Model.value_for_model(model[:path]),
+          test_type: "model_method",
+          model: model,
+          method: method_info,
+          auth_patterns: Tng::Services::UserAppConfig.config_with_source,
+          model_connections: Tng::Analyzers::Model.model_connections(model)
+        }
+
+        send_request_and_save_test(payload)
+      end
+
+      def run_for_service_method(service, method_info)
+        payload = {
+          service_test: Tng::Analyzers::Service.read_test_file_for_service(service[:path]),
+          machine_info: @machine_info,
+          object_fixture_data: Tng::Utils.fixture_content,
+          ast: Tng::Analyzers::Service.value_for_service(service[:path]),
+          test_type: "service_method",
+          service: service,
+          method: method_info,
+          auth_patterns: Tng::Services::UserAppConfig.config_with_source
+        }
+
+        send_request_and_save_test(payload)
+      end
+
+      private
+
+      def send_request_and_save_test(payload)
+        marshaled = Marshal.dump(payload)
+        compressed = Zlib::Deflate.deflate(marshaled)
+        response = @http_client.post_binary(GENERATE_TESTS_PATH, compressed)
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          debug_log("Request failed with error response") if debug_enabled?
+          return handle_request_error(response)
+        end
+
+        debug_log("Request successful, status: #{response.status}") if debug_enabled?
+
+        test_content = response.body.to_s
+        if test_content.nil? || test_content.empty?
+          debug_log("Empty response body received") if debug_enabled?
+          return handle_empty_response
+        end
+
+        debug_log("Received test content, length: #{test_content.length}") if debug_enabled?
+        Tng::Utils.save_test_file(test_content)
+      rescue JSON::ParserError => e
+        debug_log("JSON parsing failed: #{e.message}") if debug_enabled?
+        puts "❌ Failed to parse generated tests via API: #{e.message}"
+        nil
+      end
+
+      def handle_request_error(response)
+        debug_log("Handling request error: #{response.error&.message}") if debug_enabled?
+        puts "❌ Request failed: #{response.error&.message}"
+        nil
+      end
+
+      def handle_empty_response
+        debug_log("Handling empty response") if debug_enabled?
+        puts "❌ Failed to generate test via API"
+        nil
+      end
+
+      def debug_enabled?
+        ENV["DEBUG"] == "1"
+      end
+
+      def debug_log(message)
+        puts "-> DEBUG [TestGenerator]: #{message}"
+      end
+    end
+  end
+end

data/lib/tng/services/testng.rb

@@ -0,0 +1,100 @@
+module Services
+  class Testng
+    STATS_PATH = "cli/tng_rails/stats"
+
+    def initialize(http_client)
+      @http_client = http_client
+    end
+
+    def check_system_status
+      response = @http_client.ping
+
+      if response.is_a?(HTTPX::ErrorResponse)
+        return {
+          status: :error,
+          message: "Unable to connect to TNG service: #{response.error&.message}",
+          error_type: :connection_error
+        }
+      end
+
+      case response.status
+      when 200
+        begin
+          data = JSON.parse(response.body)
+          current_version = data["current_version"]
+          server_base_url = data["base_url"]
+          user_base_url = Tng::Services::UserAppConfig.base_url
+
+          if current_version > Tng::VERSION
+            return {
+              status: :version_mismatch,
+              message: "Version mismatch detected",
+              current_version: current_version,
+              gem_version: Tng::VERSION,
+              error_type: :version_mismatch
+            }
+          end
+
+          # Check for base URL mismatch
+          if server_base_url && user_base_url && server_base_url != user_base_url
+            return {
+              status: :base_url_mismatch,
+              message: "Base URL mismatch detected",
+              server_base_url: server_base_url,
+              user_base_url: user_base_url,
+              current_version: current_version,
+              gem_version: Tng::VERSION,
+              error_type: :base_url_mismatch
+            }
+          end
+
+          {
+            status: :ok,
+            message: data["message"] || "System is operational",
+            current_version: current_version,
+            gem_version: Tng::VERSION,
+            server_base_url: server_base_url
+          }
+        rescue JSON::ParserError => e
+          {
+            status: :error,
+            message: "Invalid response from server: #{e.message}",
+            error_type: :parse_error
+          }
+        end
+      else
+        {
+          status: :service_down,
+          message: "TestNG service is currently unavailable (HTTP #{response.status})",
+          error_type: :service_unavailable
+        }
+      end
+    end
+
+    def get_user_stats
+      headers = {
+        "Authorization" => "Bearer #{Tng::Services::UserAppConfig.api_key}",
+        "Content-Type" => "application/json",
+        "User-Agent" => "Tng/#{Tng::VERSION} Ruby/#{RUBY_VERSION}"
+      }
+
+      response = @http_client.get(STATS_PATH, headers: headers)
+
+      return nil if response.is_a?(HTTPX::ErrorResponse)
+
+      if response.status == 200
+        begin
+          stats_data = JSON.parse(response.body)
+          puts "✅ Statistics fetched successfully!"
+          stats_data
+        rescue JSON::ParserError => e
+          puts "❌ Failed to parse statistics response: #{e.message}"
+          nil
+        end
+      else
+        puts "❌ Failed to fetch statistics (#{response.status})"
+        nil
+      end
+    end
+  end
+end

data/lib/tng/services/user_app_config.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Tng
+  module Services
+    class UserAppConfig
+      def self.api_key
+        Tng.api_key
+      end
+
+      def self.base_url
+        Tng.base_url
+      end
+
+      def self.configured?
+        Tng.api_key && Tng.base_url
+      end
+
+      def self.missing_config
+        missing = []
+        missing << "API key" unless api_key
+        missing << "Base URL" unless base_url
+        missing
+      end
+
+      def self.config_with_source
+        auth_entry_points_with_source = []
+        methods = Tng.authentication_methods
+        methods.each do |method|
+          auth_entry_points_with_source << {
+            method: method[:method],
+            file: method[:file_location],
+            auth_type: method[:auth_type],
+            source: extract_method_source(method[:file_location], method[:method])
+          }
+        end
+        Tng.config[:authentication_entry_points_with_source] = auth_entry_points_with_source
+        Tng.config
+      end
+
+      def self.find_method_in_ast(node, method_name)
+        return nil unless node.is_a?(Prism::Node)
+
+        return node if node.is_a?(Prism::DefNode) && node.name == method_name.to_sym
+
+        node.child_nodes.each do |child|
+          result = find_method_in_ast(child, method_name)
+          return result if result
+        end
+
+        nil
+      end
+
+      def self.extract_method_source(file_path, method_name)
+        return nil unless file_path && method_name
+
+        full_path = Rails.root.join(file_path)
+        return nil unless File.exist?(full_path)
+
+        file_content = File.read(full_path)
+        result = Prism.parse(file_content)
+
+        method_node = find_method_in_ast(result.value, method_name)
+        return nil unless method_node
+
+        # Extract the method source from the original file content
+        start_line = method_node.location.start_line - 1 # Convert to 0-based index
+        end_line = method_node.location.end_line - 1
+
+        lines = file_content.lines
+        method_source = lines[start_line..end_line].join
+        method_source.strip
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/tng/ui/about_display.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "tty-box"
+require "pastel"
+require "tty-screen"
+require_relative "theme"
+
+class AboutDisplay
+  def initialize(pastel, prompt, version)
+    @pastel = pastel
+    @prompt = prompt
+    @version = version
+    @terminal_width = begin
+      TTY::Screen.width
+    rescue StandardError
+      80
+    end
+  end
+
+  def display
+    about_content = [
+      @pastel.public_send(Tng::UI::Theme.color(:secondary)).bold("About Tng"),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:primary),
+                          "Tng is an LLM-powered test generation tool for Rails applications."),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:accent), "Features:"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Controller test generation"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Model test generation"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Service test generation"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} LLM-powered test suggestions"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Test coverage analysis"),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:accent), "Technology:"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Static code analysis with Prism"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Intelligent pattern recognition"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Rails-specific optimizations"),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "Version: #{@version}"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "Built with #{Tng::UI::Theme.icon(:heart)} for Rails developers")
+    ].join("\n")
+
+    box_width = Tng::UI::Theme.calculate_box_width(@terminal_width)
+    style = Tng::UI::Theme.box_style(:default)
+
+    about_box = TTY::Box.frame(
+      title: { top_left: " About Tng " },
+      style: style[:style],
+      padding: style[:padding],
+      width: box_width
+    ) do
+      about_content
+    end
+
+    puts Tng::UI::Theme.center_box(about_box, box_width, @terminal_width)
+    @prompt.keypress(Tng::UI::Theme.center_text(
+                       @pastel.public_send(Tng::UI::Theme.color(:muted),
+                                           "Press any key to continue..."), @terminal_width
+                     ))
+  end
+end

data/lib/tng/ui/authentication_warning_display.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "tty-box"
+require "pastel"
+require "tty-screen"
+require_relative "theme"
+
+class AuthenticationWarningDisplay
+  def initialize(pastel)
+    @pastel = pastel
+    @terminal_width = begin
+      TTY::Screen.width
+    rescue StandardError
+      80
+    end
+  end
+
+  def display_if_missing
+    return false unless authentication_config_missing?
+
+    display_warning
+    handle_user_choice
+  end
+
+  def display_warning
+    warning_content = [
+      @pastel.public_send(Tng::UI::Theme.color(:error)).bold("Authentication Configuration Missing"),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:primary), "TNG needs authentication setup to generate proper tests."),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:accent), "Missing: ") + build_missing_items_summary,
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:secondary), "Quick fix:"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Edit config/initializers/tng.rb"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Uncomment authentication_methods array"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted), "#{Tng::UI::Theme.icon(:bullet)} Add your auth method details"),
+      "",
+      @pastel.public_send(Tng::UI::Theme.color(:success), "Press Enter to continue anyway"),
+      @pastel.public_send(Tng::UI::Theme.color(:error), "Press Esc to cancel and fix configuration")
+    ].join("\n")
+
+    box_width = Tng::UI::Theme.calculate_box_width(@terminal_width)
+    style = Tng::UI::Theme.box_style(:warning)
+
+    warning_box = TTY::Box.frame(
+      title: { top_left: " Auth Warning " },
+      style: style[:style],
+      padding: style[:padding],
+      width: box_width
+    ) do
+      warning_content
+    end
+
+    puts Tng::UI::Theme.center_box(warning_box, box_width, @terminal_width)
+    puts
+  end
+
+  private
+
+  def handle_user_choice
+    require "io/console"
+
+    loop do
+      key = $stdin.getch
+      case key
+      when "\r", "\n" # Enter key
+        return false # Continue anyway
+      when "\e" # Escape key
+        return true # Cancel (authentication missing)
+      when "\u0003" # Ctrl+C
+        puts "\n#{@pastel.public_send(Tng::UI::Theme.color(:warning), "Operation cancelled.")}"
+        exit(0)
+      end
+    end
+  rescue StandardError
+    # Fallback if getch is not available
+    puts @pastel.public_send(Tng::UI::Theme.color(:muted), "Press Enter to continue or Ctrl+C to cancel...")
+    gets
+    false
+  end
+
+  def build_missing_items_summary
+    issues = []
+
+    issues << "empty auth methods" if Tng.authentication_enabled && authentication_methods_empty?
+
+    issues << "invalid auth config" if !authentication_methods_empty? && !authentication_methods_valid?
+
+    issues << "auth disabled" unless Tng.authentication_enabled
+
+    issues.empty? ? "unknown issue" : issues.join(", ")
+  end
+
+  def authentication_config_missing?
+    # Check if authentication is enabled but methods are not configured
+    return true if Tng.authentication_enabled && authentication_methods_empty?
+
+    # Check if authentication methods exist but are invalid
+    return true if !authentication_methods_empty? && !authentication_methods_valid?
+
+    false
+  end
+
+  def authentication_methods_empty?
+    methods = Tng.authentication_methods
+    methods.nil? || methods.empty?
+  end
+
+  def authentication_methods_valid?
+    methods = Tng.authentication_methods
+    return false if methods.nil? || methods.empty?
+
+    methods.all? do |method|
+      method.is_a?(Hash) &&
+        method.key?(:method) && !method[:method].to_s.strip.empty? &&
+        method.key?(:file_location) && !method[:file_location].to_s.strip.empty? &&
+        method.key?(:auth_type) && !method[:auth_type].to_s.strip.empty?
+    end
+  end
+
+  def build_missing_items_list
+    issues = []
+
+    if Tng.authentication_enabled && authentication_methods_empty?
+      issues << @pastel.public_send(Tng::UI::Theme.color(:error), "  • authentication_methods array is empty")
+    end
+
+    if !authentication_methods_empty? && !authentication_methods_valid?
+      issues << @pastel.public_send(Tng::UI::Theme.color(:error), "  • authentication_methods contains invalid entries")
+
+      Tng.authentication_methods.each_with_index do |method, index|
+        next if method.is_a?(Hash)
+
+        issues << @pastel.public_send(Tng::UI::Theme.color(:muted), "    - Entry #{index + 1}: not a valid hash")
+        next
+      end
+
+      Tng.authentication_methods.each_with_index do |method, index|
+        next unless method.is_a?(Hash)
+
+        if !method.key?(:method) || method[:method].to_s.strip.empty?
+          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
+                                        "    - Entry #{index + 1}: missing or empty 'method'")
+        end
+
+        if !method.key?(:file_location) || method[:file_location].to_s.strip.empty?
+          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
+                                        "    - Entry #{index + 1}: missing or empty 'file_location'")
+        end
+
+        if !method.key?(:auth_type) || method[:auth_type].to_s.strip.empty?
+          issues << @pastel.public_send(Tng::UI::Theme.color(:muted),
+                                        "    - Entry #{index + 1}: missing or empty 'auth_type'")
+        end
+      end
+    end
+
+    unless Tng.authentication_enabled
+      issues << @pastel.public_send(Tng::UI::Theme.color(:warning),
+                                    "  • authentication_enabled is set to false")
+    end
+
+    if issues.empty?
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "  • Configuration appears valid")
+    else
+      issues.join("\n")
+    end
+  end
+end