tng 0.3.0 → 0.3.3

data/lib/tng/api/http_client.rb

@@ -70,6 +70,25 @@ module Tng
       response
     end
 
+    # Verify if the API key is valid
+    # Returns: { valid: true/false, error: nil/String }
+    def verify_auth
+      response = get("cli/tng_rails/stats")
+
+      return { valid: false, error: "Network error" } if response.is_a?(HTTPX::ErrorResponse)
+
+      case response.status
+      when 200, 201
+        { valid: true, error: nil }
+      when 401
+        { valid: false, error: "Invalid or missing API key" }
+      when 403
+        { valid: false, error: "API key expired or usage limit reached" }
+      else
+        { valid: false, error: "Unexpected error (#{response.status})" }
+      end
+    end
+
     private
 
     def stream_default_headers

data/lib/tng/services/test_generator.rb

@@ -20,53 +20,49 @@ module Tng
         @pastel = Pastel.new
       end
 
-      def run_for_controller_method(controller, method_info)
-        generate_test_for_type(controller, method_info, :controller)
+      def run_for_controller_method(controller, method_info, progress: nil)
+        generate_test_for_type(controller, method_info, :controller, progress: progress)
       end
 
-      def run_for_model_method(model, method_info)
-        generate_test_for_type(model, method_info, :model)
+      def run_for_model_method(model, method_info, progress: nil)
+        generate_test_for_type(model, method_info, :model, progress: progress)
       end
 
-      def run_for_service_method(service, method_info)
-        generate_test_for_type(service, method_info, :service)
+      def run_for_service_method(service, method_info, progress: nil)
+        generate_test_for_type(service, method_info, :service, progress: progress)
       end
 
-      def run_for_other_method(other_file, method_info)
-        generate_test_for_type(other_file, method_info, :other)
+      def run_for_other_method(other_file, method_info, progress: nil)
+        generate_test_for_type(other_file, method_info, :other, progress: progress)
       end
 
-      private
 
-      def generate_test_for_type(file_object, method_info, type)
+      def generate_test_for_type(file_object, method_info, type, progress: nil)
         start_time = Time.now
 
         response = send_request_for_type(file_object, method_info, type)
         return unless response
 
         if response.is_a?(HTTPX::ErrorResponse)
-          error_icon = Tng::UI::Theme.icon(:error)
-          error_color = Tng::UI::Theme.color(:error)
-          puts "#{error_icon} #{@pastel.decorate("Request failed:",
-                                                 error_color)} #{response.error&.message || "Unknown error"}"
-          return
+          return { error: :network_error, message: response.error&.message || "Network error" }
         end
 
         job_data = JSON.parse(response.body)
 
+        # Check for authentication errors
+        if response.status == 401
+          return { error: :auth_failed, message: "Invalid or missing API key" }
+        end
+
         # Check for forbidden responses (usage limits or invalid keys)
         if response.status == 403
-          error_icon = Tng::UI::Theme.icon(:error)
-          error_color = Tng::UI::Theme.color(:error)
-          puts "#{error_icon} #{@pastel.decorate("Access denied:",
-                                                 error_color)} Please check your API key and usage limits."
-          return
+          return { error: :auth_failed, message: "API key expired or usage limit reached" }
         end
         job_id = job_data["job_id"]
 
         return unless job_id
 
-        result = poll_for_completion(job_id)
+        result = poll_for_completion(job_id, progress: progress)
 
         return unless result
 
@@ -106,21 +102,57 @@ module Tng
         ]
       end
 
-      def poll_for_completion(job_id)
+      def poll_for_completion(job_id, progress: nil)
         start_time = Time.current
-        progress_bar = create_progress_bar
+        attempts = 0
+        max_attempts = MAX_POLL_DURATION_SECONDS / POLL_INTERVAL_SECONDS
+
+        # Initialize agent steps if progress tracking is enabled
+        agent_step_indices = {}
+        if progress
+          # Current step index in progress updater (assuming it follows previous steps)
+          # We create 4 generic steps for the agents
+          # Note: indices are relative to the current session, so we just append them.
+          # But we need their indices to update them later.
+          # Since we can't ask progress for current index easily without hacking, 
+          # we rely on the fact that we call update 4 times.
+          
+          # Use a base offset if we could know it, but we can't reliably.
+          # Actually, if we use explicit_step, we need absolute indices.
+          # Let's assume the previous steps were 0, 1, 2, 3 based on bin/tng.
+          # So we start at 4.
+          base_idx = 4 
+          
+          progress.update("Context Builder: Pending...", nil, step_increment: true)
+          agent_step_indices["context_agent_status"] = base_idx
+
+          progress.update("Style Analyzer: Pending...", nil, step_increment: true)
+          agent_step_indices["style_agent_status"] = base_idx + 1
+
+          progress.update("Logic Analyzer: Pending...", nil, step_increment: true)
+          agent_step_indices["logical_issue_status"] = base_idx + 2
+
+          progress.update("Logic Generator: Pending...", nil, step_increment: true)
+          agent_step_indices["behavior_expert_status"] = base_idx + 3
+        end
 
         loop do
+          attempts += 1
           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 (7 minutes)"
-            return
+            return { error: :timeout, message: "Test generation timed out after #{MAX_POLL_DURATION_SECONDS} seconds" }
           end
 
-          status_text = determine_status_text(seconds_elapsed)
-          progress_bar.advance(1, status: status_text)
+          # Calculate pseudo-percentage
+          if progress
+             pct = ((attempts.to_f / max_attempts.to_f) * 95.0).to_i
+             # Update global progress bar without adding a new step (explicit_step=4 updates Context Builder line, but we want to just update percentage?)
+             # The progress bar component takes the percent from the *last* update message.
+             # So we can pass specific percent when we update any agent step.
+          else
+            pct = 0
+          end
 
           sleep(POLL_INTERVAL_SECONDS)
 
@@ -128,31 +160,73 @@ module Tng
 
           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
+            next
           end
 
           begin
             status_data = JSON.parse(status_response.body.to_s)
             status = status_data["status"]
+            
+            # Update UI with granular info
+            if progress && status_data["info"].is_a?(Hash)
+              info = status_data["info"]
+              
+              agent_step_indices.each do |key, step_idx|
+                 item_data = info[key]
+                 next unless item_data
+
+                 agent_status = "pending"
+                 values = []
+
+                 if item_data.is_a?(Hash)
+                   agent_status = item_data["status"] || "pending"
+                   values = item_data["values"] || []
+                 else
+                   agent_status = item_data.to_s
+                 end
+
+                 label = case key
+                         when "context_agent_status" then "Context Builder"
+                         when "style_agent_status" then "Style Analyzer"
+                         when "logical_issue_status" then "Logic Analyzer"
+                         when "behavior_expert_status" then "Logic Generator"
+                         else key
+                         end
+
+                msg = if agent_status == "processing"
+                        "#{label}: Processing..."
+                      elsif agent_status == "completed"
+                        "#{label}: Completed"
+                      elsif agent_status == "failed"
+                        "#{label}: Failed"
+                      else
+                        "#{label}: #{agent_status.capitalize}..."
+                      end
+
+                if values.any?
+                  # Clean values
+                  clean_vals = values.map { |v| v.to_s.gsub("_", " ").gsub("'", "").gsub(":", "").strip }
+                  display_str = clean_vals.first(3).join(", ")
+                  display_str += ", ..." if clean_vals.size > 3
+                  msg += " (#{display_str})"
+                end
+
+                # Pass percentage only on the last step (Logic Generator) to keep main bar moving?
+                # Or pass it on all updates.
+                p = (step_idx == agent_step_indices["behavior_expert_status"]) ? pct : nil
+                
+                progress.update(msg, p, step_increment: false, explicit_step: step_idx)
+              end
+            end
 
             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)} An error occurred while generating tests. Please try again."
-              return
+              return { error: :generation_failed, message: status_data["error"] }
             when "pending", "processing"
-              # Progress bar updates smoothly above
               next
             else
               debug_log("Unknown test generation status: #{status}") if debug_enabled?
@@ -165,47 +239,6 @@ module Tng
         end
       end
 
-      def create_progress_bar
-        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("\u2593", success_color)
-        incomplete_char = @pastel.decorate("\u2591", muted_color)
-        head_char = @pastel.decorate("\u25B6", success_color)
-
-        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
-        )
-      end
-
-      def determine_status_text(seconds_elapsed)
-        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
-      end
-
       def trigger_cleanup(job_id)
         @http_client.patch("#{CONTENT_RESPONSES_PATH}/#{job_id}/cleanup")
       rescue StandardError => e

data/lib/tng/services/testng.rb

@@ -84,16 +84,10 @@ module Services
 
       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}"
+          JSON.parse(response.body)
+        rescue JSON::ParserError
           nil
         end
-      else
-        puts "❌ Failed to fetch statistics (#{response.status})"
-        nil
       end
     end
   end