tng 0.1.6 → 0.2.2

data/lib/tng/services/test_generator.rb

@@ -3,148 +3,276 @@
 require "zlib"
 require "tng/utils"
 require "tng/services/user_app_config"
+require "tng/ui/theme"
+require "pastel"
 
 module Tng
   module Services
     class TestGenerator
       GENERATE_TESTS_PATH = "cli/tng_rails/contents/generate_tests"
+      CONTENT_RESPONSES_PATH = "cli/tng_rails/content_responses"
+      POLL_INTERVAL_SECONDS = 5 # Poll every 5 seconds
+      MAX_POLL_DURATION_SECONDS = 360 # 6 minutes total
 
       def initialize(http_client)
         @http_client = http_client
         @machine_info = Tng.machine_info
+        @pastel = Pastel.new
       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_controller_method(controller, method_info)
+        start_time = Time.now
 
-      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
+        response = Tng.send_request_for_controller(
+          controller[:name],
+          controller[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
 
-      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
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
 
-      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)
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
       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)
+        start_time = Time.now
+
+        response = Tng.send_request_for_model(
+          model[:name],
+          model[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
       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)
+        start_time = Time.now
+
+        response = Tng.send_request_for_service(
+          service[:name],
+          service[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
+      end
+
+      def run_for_other_method(other_file, method_info)
+        start_time = Time.now
+
+        response = Tng.send_request_for_other(
+          other_file[:name] || File.basename(other_file[:path], ".rb"),
+          other_file[:path],
+          method_info[:name],
+          Tng::Utils.fixture_content,
+          Tng::Services::UserAppConfig.config_with_source,
+          Tng::Services::UserAppConfig.base_url,
+          Tng::Services::UserAppConfig.api_key
+        )
+
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
+
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+
+        return unless result
+
+        end_time = Time.now
+        generation_time = end_time - start_time
+
+        file_result = Tng::Utils.save_test_file(result.to_json)
+        return unless file_result
+
+        file_result.merge(generation_time: generation_time)
       end
 
       private
 
       def send_request_and_save_test(payload)
+        job_id = submit_async_job(payload)
+        return unless job_id
+
+        result = poll_for_completion(job_id)
+        return unless result
+
+        Tng::Utils.save_test_file(result.to_json)
+      rescue StandardError => e
+        debug_log("Async request failed: #{e.message}") if debug_enabled?
+        puts "❌ Failed to generate test: #{e.message}"
+        nil
+      end
+
+      def submit_async_job(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)
+          debug_log("Processing test failed") if debug_enabled?
+          puts "❌ Failed to submit test generation job: #{response.error&.message}"
+          return
         end
 
-        debug_log("Request successful, status: #{response.status}") if debug_enabled?
+        job_data = JSON.parse(response.body)
+        job_id = job_data["job_id"]
 
-        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("Processing test with id: #{job_id}") if debug_enabled?
 
-        debug_log("Received test content, length: #{test_content.length}") if debug_enabled?
-        Tng::Utils.save_test_file(test_content)
+        job_id
       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
+        debug_log("Failed to parse API response: #{e.message}") if debug_enabled?
+        puts "❌ Failed to parse API response. Please retry."
       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 poll_for_completion(job_id)
+        start_time = Time.current
 
-      def handle_empty_response
-        debug_log("Handling empty response") if debug_enabled?
-        puts "❌ Failed to generate test via API"
-        nil
+        rocket_icon = Tng::UI::Theme.icon(:rocket)
+        success_color = Tng::UI::Theme.color(:success)
+        primary_color = Tng::UI::Theme.color(:primary)
+        muted_color = Tng::UI::Theme.color(:muted)
+
+        complete_char = @pastel.decorate("▓", success_color)
+        incomplete_char = @pastel.decorate("░", muted_color)
+        head_char = @pastel.decorate("▶", success_color)
+
+        progress_bar = TTY::ProgressBar.new(
+          "#{rocket_icon} #{@pastel.decorate("Generating tests",
+                                             primary_color)} #{@pastel.decorate("[:bar]",
+                                                                                :white)} #{@pastel.decorate(":status",
+                                                                                                            muted_color)} #{@pastel.decorate(
+                                                                                                              "(:elapsed)", muted_color
+                                                                                                            )}",
+          total: nil,
+          complete: complete_char,
+          incomplete: incomplete_char,
+          head: head_char,
+          width: 40,
+          clear: true,
+          frequency: 10,  # Update 10 times per second for smooth animation
+          interval: 1     # Show elapsed time updates every second
+        )
+
+        loop do
+          seconds_elapsed = (Time.current - start_time).to_i
+
+          if seconds_elapsed > MAX_POLL_DURATION_SECONDS
+            progress_bar.finish
+            puts "❌ Test generation timed out after #{MAX_POLL_DURATION_SECONDS} seconds (6 minutes)"
+            return
+          end
+
+          status_text = case seconds_elapsed
+                        when 0..15 then "initializing..."
+                        when 16..45 then "analyzing code structure..."
+                        when 46..90 then "generating test cases..."
+                        when 91..150 then "optimizing test logic..."
+                        when 151..210 then "refining assertions..."
+                        when 211..270 then "formatting output..."
+                        when 271..330 then "finalizing tests..."
+                        else "completing generation..."
+                        end
+          progress_bar.advance(1, status: status_text)
+
+          sleep(POLL_INTERVAL_SECONDS)
+
+          status_response = @http_client.get("#{CONTENT_RESPONSES_PATH}/#{job_id}")
+
+          if status_response.is_a?(HTTPX::ErrorResponse)
+            debug_log("Status check failed: #{status_response.error&.message}") if debug_enabled?
+            next # Continue polling on network errors
+          end
+
+          begin
+            status_data = JSON.parse(status_response.body.to_s)
+            status = status_data["status"]
+
+            case status
+            when "completed"
+              debug_log("Test generation completed!") if debug_enabled?
+              progress_bar.finish
+              success_icon = Tng::UI::Theme.icon(:success)
+              success_color = Tng::UI::Theme.color(:success)
+              puts "#{success_icon} #{@pastel.decorate("Test generation completed!", success_color)}"
+              return status_data["result"]
+            when "failed"
+              debug_log("Test generation failed: #{status_data["error"]}") if debug_enabled?
+              progress_bar.finish
+              error_icon = Tng::UI::Theme.icon(:error)
+              error_color = Tng::UI::Theme.color(:error)
+              puts "#{error_icon} #{@pastel.decorate("Test generation failed:",
+                                                     error_color)} #{status_data["error"] || "Unknown error"}"
+              return
+            when "pending", "processing"
+              # Progress bar updates smoothly above
+              next
+            else
+              debug_log("Unknown test generation status: #{status}") if debug_enabled?
+              next
+            end
+          rescue JSON::ParserError => e
+            debug_log("Failed to parse response status: #{e.message}") if debug_enabled?
+            next
+          end
+        end
       end
 
       def debug_enabled?

data/lib/tng/services/testng.rb

@@ -21,7 +21,7 @@ module Services
       when 200
         begin
           data = JSON.parse(response.body)
-          current_version = data["current_version"]
+          current_version = data["current_version"]["gem_version"]
           server_base_url = data["base_url"]
           user_base_url = Tng::Services::UserAppConfig.base_url
 
@@ -80,7 +80,7 @@ module Services
 
       response = @http_client.get(STATS_PATH, headers: headers)
 
-      return nil if response.is_a?(HTTPX::ErrorResponse)
+      return if response.is_a?(HTTPX::ErrorResponse)
 
       if response.status == 200
         begin

data/lib/tng/services/user_app_config.rb

@@ -38,7 +38,7 @@ module Tng
       end
 
       def self.find_method_in_ast(node, method_name)
-        return nil unless node.is_a?(Prism::Node)
+        return unless node.is_a?(Prism::Node)
 
         return node if node.is_a?(Prism::DefNode) && node.name == method_name.to_sym
 
@@ -51,19 +51,18 @@ module Tng
       end
 
       def self.extract_method_source(file_path, method_name)
-        return nil unless file_path && method_name
+        return unless file_path && method_name
 
         full_path = Rails.root.join(file_path)
-        return nil unless File.exist?(full_path)
+        return 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
+        return 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
+        start_line = method_node.location.start_line - 1
         end_line = method_node.location.end_line - 1
 
         lines = file_content.lines

data/lib/tng/ui/about_display.rb

@@ -19,15 +19,17 @@ class AboutDisplay
 
   def display
     about_content = [
-      @pastel.public_send(Tng::UI::Theme.color(:secondary)).bold("About Tng"),
       "",
-      @pastel.public_send(Tng::UI::Theme.color(:primary),
+      @pastel.public_send(Tng::UI::Theme.color(:secondary),
                           "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)} 20+ Rails file types supported"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Core: Controllers, Models, Services"),
+      @pastel.public_send(Tng::UI::Theme.color(:muted),
+                          "#{Tng::UI::Theme.icon(:bullet)} Extended: Jobs, Helpers, Lib, Policies, Presenters, Mailers, GraphQL + more"),
       @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"),
       "",

data/lib/tng/ui/controller_test_flow_display.rb

@@ -37,23 +37,6 @@ class ControllerTestFlowDisplay
     end
   end
 
-  def select_test_option(controller_choice)
-    header = @pastel.public_send(Tng::UI::Theme.color(:primary)).bold("#{Tng::UI::Theme.icon(:rocket)} Test Generation Options for #{controller_choice[:name]}")
-    puts Tng::UI::Theme.center_text(header, @terminal_width)
-    puts
-
-    @prompt.select(
-      @pastel.public_send(Tng::UI::Theme.color(:primary), "Choose test generation type:"),
-      cycle: true,
-      symbols: { marker: Tng::UI::Theme.icon(:marker) }
-    ) do |menu|
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:success), "Generate all possible tests"),
-                  :all_possible_tests
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:info), "Generate per method"), :per_method
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:secondary), "#{Tng::UI::Theme.icon(:back)}  Back"), :back
-    end
-  end
-
   def show_no_controllers_message
     error_msg = "#{@pastel.public_send(Tng::UI::Theme.color(:error)).bold("#{Tng::UI::Theme.icon(:error)} No controllers found in your application")}\n#{@pastel.public_send(
       Tng::UI::Theme.color(:muted), "Make sure you have controllers in app/controllers/"

data/lib/tng/ui/model_test_flow_display.rb

@@ -36,23 +36,6 @@ class ModelTestFlowDisplay
     end
   end
 
-  def select_test_option(model_choice)
-    header = @pastel.public_send(Tng::UI::Theme.color(:primary)).bold("#{Tng::UI::Theme.icon(:rocket)} Test Generation Options for #{model_choice[:name]}")
-    puts Tng::UI::Theme.center_text(header, @terminal_width)
-    puts
-
-    @prompt.select(
-      @pastel.public_send(Tng::UI::Theme.color(:primary), "Choose test generation type:"),
-      cycle: true,
-      symbols: { marker: Tng::UI::Theme.icon(:marker) }
-    ) do |menu|
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:success), "Generate all possible tests"),
-                  :all_possible_tests
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:info), "Generate per method"), :per_method
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:secondary), "#{Tng::UI::Theme.icon(:back)}  Back"), :back
-    end
-  end
-
   def show_no_models_message
     puts
     puts Tng::UI::Theme.center_text(

data/lib/tng/ui/other_test_flow_display.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tty-spinner"
+require "pastel"
+require "tty-screen"
+require_relative "theme"
+
+class OtherTestFlowDisplay
+  def initialize(prompt, pastel)
+    @prompt = prompt
+    @pastel = pastel
+    @terminal_width = begin
+      TTY::Screen.width
+    rescue StandardError
+      80
+    end
+  end
+
+  def select_other_file(other_files)
+    header = @pastel.public_send(Tng::UI::Theme.color(:primary)).bold("#{Tng::UI::Theme.icon(:config)} Select file to test:")
+    puts Tng::UI::Theme.center_text(header, @terminal_width)
+
+    @prompt.select(
+      "",
+      cycle: true,
+      per_page: 12,
+      filter: true,
+      symbols: { marker: Tng::UI::Theme.icon(:marker) }
+    ) do |menu|
+      other_files.each do |file|
+        display_name = "#{file[:name]} #{@pastel.public_send(Tng::UI::Theme.color(:muted), "(#{file[:path]})")}"
+        menu.choice display_name, file
+      end
+      menu.choice @pastel.public_send(Tng::UI::Theme.color(:secondary), "#{Tng::UI::Theme.icon(:back)}  Back"), :back
+    end
+  end
+
+  def show_no_other_files_message
+    error_msg = "#{@pastel.public_send(Tng::UI::Theme.color(:error)).bold("#{Tng::UI::Theme.icon(:error)} No other files found in your application")}\n#{@pastel.public_send(
+      Tng::UI::Theme.color(:muted), "Make sure you have files in supported directories (app/jobs, app/helpers, lib/, app/policies, app/presenters, app/mailers, app/graphql, etc.)"
+    )}"
+    puts Tng::UI::Theme.center_text(error_msg, @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
+
+  def select_other_method(other_file, methods)
+    header = @pastel.public_send(Tng::UI::Theme.color(:primary)).bold("#{Tng::UI::Theme.icon(:rocket)} Select method to test in #{other_file[:name]}")
+    puts Tng::UI::Theme.center_text(header, @terminal_width)
+
+    @prompt.select(
+      "",
+      cycle: true,
+      per_page: 10,
+      filter: true,
+      symbols: { marker: Tng::UI::Theme.icon(:marker) }
+    ) do |menu|
+      methods.each do |method|
+        menu.choice method[:name], method
+      end
+      menu.choice @pastel.public_send(Tng::UI::Theme.color(:secondary), "#{Tng::UI::Theme.icon(:back)}  Back"), :back
+    end
+  end
+
+  def show_no_methods_message(other_file)
+    error_msg = "#{@pastel.public_send(Tng::UI::Theme.color(:error)).bold("#{Tng::UI::Theme.icon(:error)} No methods found in #{other_file[:name]}")}\n#{@pastel.public_send(
+      Tng::UI::Theme.color(:muted), "File may be empty or have syntax errors"
+    )}"
+    puts Tng::UI::Theme.center_text(error_msg, @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/post_install_box.rb

@@ -38,25 +38,23 @@ class PostInstallBox
       pastel.public_send(Tng::UI::Theme.color(:primary), "Interactive mode:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
                          "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                 "  - Full interactive CLI"),
+                                                                                                 "  - Interactive CLI with method selection"),
       "",
-      pastel.public_send(Tng::UI::Theme.color(:primary), "Direct generation:"),
+      pastel.public_send(Tng::UI::Theme.color(:primary), "Features:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng -t c -f ping") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                              "  - Short"),
+                         "#{Tng::UI::Theme.icon(:bullet)} Test 20+ file types: Controllers, Models, Services + Jobs, Helpers, Lib, Policies, Presenters, Mailers, GraphQL, and more"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng -t=c f=ping") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                             "   - Mixed"),
+                         "#{Tng::UI::Theme.icon(:bullet)} Select specific methods to test"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng --type=controller --file=ping"),
+                         "#{Tng::UI::Theme.icon(:bullet)} Search and filter through methods"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary), "Help:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
                          "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng --help") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                        "  - Show all options"),
+                                                                                                        "  - Show help information"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:muted),
-                         "#{Tng::UI::Theme.icon(:lightbulb)} Use -t c for controller, -t m for model")
+                         "#{Tng::UI::Theme.icon(:lightbulb)} Generate tests for individual methods with precision")
     ].join("\n")
   end
 

data/lib/tng/ui/service_test_flow_display.rb

@@ -36,23 +36,6 @@ class ServiceTestFlowDisplay
     end
   end
 
-  def select_test_option(service_choice)
-    header = @pastel.public_send(Tng::UI::Theme.color(:primary)).bold("#{Tng::UI::Theme.icon(:rocket)} Test Generation Options for #{service_choice[:name]}")
-    puts Tng::UI::Theme.center_text(header, @terminal_width)
-    puts
-
-    @prompt.select(
-      @pastel.public_send(Tng::UI::Theme.color(:primary), "Choose test generation type:"),
-      cycle: true,
-      symbols: { marker: Tng::UI::Theme.icon(:marker) }
-    ) do |menu|
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:success), "Generate all possible tests"),
-                  :all_possible_tests
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:info), "Generate per method"), :per_method
-      menu.choice @pastel.public_send(Tng::UI::Theme.color(:secondary), "#{Tng::UI::Theme.icon(:back)}  Back"), :back
-    end
-  end
-
   def show_no_services_message
     error_msg = "#{@pastel.public_send(Tng::UI::Theme.color(:error)).bold("#{Tng::UI::Theme.icon(:error)} No services found in your application")}\n#{@pastel.public_send(
       Tng::UI::Theme.color(:muted), "Make sure you have services in app/services/ or app/service/"