tng 0.1.0

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,71 @@
+# frozen_string_literal: true
+
+require "tty-box"
+require "pastel"
+require "tty-screen"
+
+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.cyan.bold("About Tng"),
+      "",
+      @pastel.bright_white("Tng is an LLM-powered test generation tool for Rails applications."),
+      "",
+      @pastel.bold("Features:"),
+      "• Controller test generation",
+      "• Model test generation",
+      "• LLM-powered test suggestions",
+      "• Test coverage analysis",
+      "",
+      @pastel.bold("Technology:"),
+      "• Static code analysis with Prism",
+      "• Intelligent pattern recognition",
+      "• Rails-specific optimizations",
+      "",
+      @pastel.dim("Version: #{@version}"),
+      @pastel.dim("Built with ❤️  for Rails developers")
+    ].join("\n")
+
+    box_width = 64
+    about_box = TTY::Box.frame(
+      title: { top_left: " About Tng " },
+      style: {
+        fg: :bright_white,
+        border: { fg: :cyan },
+        title: { fg: :bright_cyan }
+      },
+      padding: [1, 2],
+      width: box_width
+    ) do
+      about_content
+    end
+
+    puts center_box(about_box, box_width)
+    @prompt.keypress(center_text(@pastel.dim("Press any key to continue...")))
+  end
+
+  private
+
+  def center_text(text)
+    padding = (@terminal_width - @pastel.strip(text).length) / 2
+    padding = 0 if padding.negative?
+    (" " * padding) + text
+  end
+
+  def center_box(box_string, box_width)
+    padding = (@terminal_width - box_width) / 2
+    padding = 0 if padding.negative?
+    box_string.lines.map { |line| (" " * padding) + line.chomp }.join("\n")
+  end
+end

data/lib/tng/ui/configuration_display.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-screen"
+
+class ConfigurationDisplay
+  def initialize(pastel)
+    @pastel = pastel
+    @terminal_width = begin
+      TTY::Screen.width
+    rescue StandardError
+      80
+    end
+  end
+
+  def display_missing_config(missing_config)
+    puts @pastel.red.bold("❌ Configuration Required!")
+    puts
+    puts @pastel.yellow("Missing required configuration:")
+    missing_config.each do |key|
+      puts @pastel.cyan("  • #{key}")
+    end
+    puts
+    puts @pastel.bright_white("Please edit your configuration file:")
+    puts @pastel.cyan("  config/initializers/tng.rb")
+    puts
+    puts @pastel.bright_white("Ensure these values are set:")
+    puts @pastel.cyan("  Tng.configure do |config|")
+    puts @pastel.cyan("    config.api_key = \"your-api-key-here\"") if missing_config.include?("api_key")
+    puts @pastel.cyan("    config.testing_framework = \"minitest\"") if missing_config.include?("test_framework")
+    puts @pastel.cyan("  end")
+    puts
+    puts @pastel.dim("💡 Run 'rails generate tng:install' to create a proper config file.")
+    puts @pastel.dim("💡  Verify the generated setup corresponds to your project settings.")
+    puts
+    puts @pastel.yellow("After configuring, run 'bundle exec tng' again.")
+  end
+
+  private
+
+  def center_text(text)
+    padding = (@terminal_width - @pastel.strip(text).length) / 2
+    padding = 0 if padding.negative?
+    (" " * padding) + text
+  end
+end

data/lib/tng/ui/controller_test_flow_display.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tty-spinner"
+require "pastel"
+require "tty-screen"
+
+class ControllerTestFlowDisplay
+  def initialize(prompt, pastel)
+    @prompt = prompt
+    @pastel = pastel
+    @terminal_width = begin
+      TTY::Screen.width
+    rescue StandardError
+      80
+    end
+  end
+
+  def select_controller(controllers)
+    header = @pastel.bright_white.bold("📋 Select controller to test:")
+    puts center_text(header)
+
+    @prompt.select(
+      "",
+      cycle: true,
+      per_page: 12,
+      filter: true,
+      symbols: { marker: "▶" }
+    ) do |menu|
+      controllers.each do |controller|
+        display_name = "#{controller[:name]} #{@pastel.dim("(#{controller[:path]})")}"
+        menu.choice display_name, controller
+      end
+      menu.choice @pastel.cyan("⬅️  Back"), :back
+    end
+  end
+
+  def select_test_option(controller_choice)
+    header = @pastel.bright_white.bold("🎯 Test Generation Options for #{controller_choice[:name]}")
+    puts center_text(header)
+    puts
+
+    @prompt.select(
+      @pastel.bright_white("Choose test generation type:"),
+      cycle: true,
+      symbols: { marker: "▶" }
+    ) do |menu|
+      menu.choice @pastel.green("Generate all possible tests"), :all_possible_tests
+      menu.choice @pastel.blue("Generate per method"), :per_method
+      menu.choice @pastel.cyan("⬅️  Back"), :back
+    end
+  end
+
+  def show_no_controllers_message
+    error_msg = "#{@pastel.red.bold("❌ No controllers found in your application")}\n#{@pastel.dim("Make sure you have controllers in app/controllers/")}"
+    puts center_text(error_msg)
+    @prompt.keypress(center_text(@pastel.dim("Press any key to continue...")))
+  end
+
+  def select_controller_method(controller, methods)
+    header = @pastel.bright_white.bold("🎯 Select method to test in #{controller[:name]}")
+    puts center_text(header)
+
+    @prompt.select(
+      "",
+      cycle: true,
+      per_page: 10,
+      filter: true,
+      symbols: { marker: "▶" }
+    ) do |menu|
+      methods.each do |method|
+        menu.choice method[:name], method
+      end
+      menu.choice @pastel.cyan("⬅️  Back"), :back
+    end
+  end
+
+  def show_no_methods_message(controller)
+    error_msg = "#{@pastel.red.bold("❌ No methods found in #{controller[:name]}")}\n#{@pastel.dim("Controller may be empty or have syntax errors")}"
+    puts center_text(error_msg)
+    @prompt.keypress(center_text(@pastel.dim("Press any key to continue...")))
+  end
+
+  def center_text(text)
+    padding = (@terminal_width - @pastel.strip(text).length) / 2
+    padding = 0 if padding.negative?
+    (" " * padding) + text
+  end
+end