tng 0.3.8 → 0.4.0

data/lib/tng/services/direct_generation.rb

@@ -8,29 +8,42 @@ module Tng
     class DirectGeneration
       include ExtractMethods
 
-      def initialize(pastel, testng, http_client, params, show_post_generation_menu_proc)
+      def initialize(pastel, testng, http_client, params, show_post_generation_menu_proc, go_ui)
         @pastel = pastel
         @testng = testng
         @http_client = http_client
         @params = params
         @show_post_generation_menu = show_post_generation_menu_proc
+        @go_ui = go_ui
+      end
+
+      # ... (rest of methods)
+
+      def display_audit_results(result)
+        audit_results = result[:audit_results]
+        return unless audit_results
+
+        # Use Go UI to display rich audit results
+        # "issues" type handles both issues and behaviours in the unified view
+        @go_ui.show_audit_results(audit_results, "issues")
       end
 
       def run
-        file_path, method_name = @params[:file], @params[:method]
+        file_path = @params[:file]
+        method_name = @params[:method]
 
         unless file_path && method_name
-          puts @pastel.red("❌ Both file and method parameters are required")
-          puts @pastel.yellow("Usage: bundle exec tng app/controllers/users_controller.rb index")
-          puts @pastel.yellow("   or: bundle exec tng --file=users_controller.rb --method=index")
-          puts @pastel.yellow("   or: bundle exec tng f=users_controller.rb m=index")
+          @go_ui.display_error(@pastel.red("❌ Both file and method parameters are required"))
+          @go_ui.display_warning(@pastel.yellow("Usage: bundle exec tng app/controllers/users_controller.rb index"))
+          @go_ui.display_warning(@pastel.yellow("   or: bundle exec tng --file=users_controller.rb --method=index"))
+          @go_ui.display_warning(@pastel.yellow("   or: bundle exec tng f=users_controller.rb m=index"))
           return
         end
 
         resolved_path = FileTypeDetector.resolve_file_path(file_path)
 
         unless resolved_path && File.exist?(resolved_path)
-          puts @pastel.red("❌ File not found: #{file_path}")
+          @go_ui.display_error(@pastel.red("❌ File not found: #{file_path}"))
           suggest_similar_files(file_path)
           return
         end
@@ -42,15 +55,14 @@ module Tng
       private
 
       def suggest_similar_files(file_path)
-        base_name = File.basename(file_path, '.rb')
-        puts @pastel.yellow("💡 Did you mean one of these?")
+        base_name = File.basename(file_path, ".rb")
 
         similar_files = find_similar_files(base_name)
 
         if similar_files.empty?
-          puts @pastel.dim("  No similar files found")
+          @go_ui.display_info(@pastel.dim("  No similar files found"))
         else
-          similar_files.first(5).each { |file| puts @pastel.dim("  • #{file}") }
+          @go_ui.display_list(@pastel.yellow("💡 Did you mean one of these?"), similar_files.first(5))
         end
       end
 
@@ -61,8 +73,8 @@ module Tng
         %w[app/controllers app/models app/services app/service].each do |dir|
           next unless Dir.exist?(File.join(rails_root, dir))
 
-          Dir.glob(File.join(rails_root, dir, '**', "*#{base_name}*.rb")).each do |file|
-            similar_files << file.gsub(/^#{Regexp.escape(rails_root)}\//, '')
+          Dir.glob(File.join(rails_root, dir, "**", "*#{base_name}*.rb")).each do |file|
+            similar_files << file.gsub(%r{^#{Regexp.escape(rails_root)}/}, "")
           end
         end
 
@@ -74,27 +86,34 @@ module Tng
         methods = extract_methods_for_type(file_object, type)
 
         if methods.empty?
-          puts @pastel.yellow("⚠️  No methods found in #{file_object[:name]}")
+          @go_ui.display_warning(@pastel.yellow("⚠️  No methods found in #{file_object[:name]}"))
           return
         end
 
         method_info = methods.find { |m| m[:name].downcase == method_name.downcase }
 
         unless method_info
-          puts @pastel.red("❌ Method '#{method_name}' not found in #{file_object[:name]}")
-          puts @pastel.yellow("Available methods:")
-          methods.first(10).each { |m| puts @pastel.dim("  • #{m[:name]}") }
+          @go_ui.display_error(@pastel.red("❌ Method '#{method_name}' not found in #{file_object[:name]}"))
+          @go_ui.display_list(@pastel.yellow("Available methods:"), methods.first(10).map { |m| m[:name] })
           return
         end
 
-        puts @pastel.bright_white("🎯 Generating test for #{file_object[:name]}##{method_info[:name]}...")
+        @go_ui.display_info(@pastel.bright_white("🎯 #{@params[:audit] ? "Auditing" : "Generating test for"} #{file_object[:name]}##{method_info[:name]}..."))
 
-        result = generate_test_result(file_object, method_info, type)
+        result = @go_ui.show_progress("Processing...") do |progress|
+          generate_test_result(file_object, method_info, type, progress)
+        end
 
-        if result && result[:file_path]
+        if result&.dig(:error)
+          @go_ui.display_error(@pastel.red("❌ #{@params[:audit] ? "Audit" : "Test generation"} failed: #{result[:message]}"))
+        elsif @params[:audit]
+          # Audit mode - display results inline
+          display_audit_results(result)
+        elsif result && result[:file_path]
+          # Test generation mode - show post-generation menu
           @show_post_generation_menu.call(result)
         else
-          puts @pastel.red("❌ Failed to generate test")
+          @go_ui.display_error(@pastel.red("❌ Failed to generate test"))
         end
       end
 
@@ -107,14 +126,25 @@ module Tng
         end
       end
 
-      def generate_test_result(file_object, method_info, type)
+      def generate_test_result(file_object, method_info, type, progress)
         generator = Tng::Services::TestGenerator.new(@http_client)
 
-        case type
-        when "controller" then generator.run_for_controller_method(file_object, method_info)
-        when "model" then generator.run_for_model_method(file_object, method_info)
-        when "service" then generator.run_for_service_method(file_object, method_info)
-        else generator.run_for_other_method(file_object, method_info)
+        if @params[:audit]
+          # Audit mode - return issues and behaviours
+          case type
+          when "controller" then generator.run_audit_for_controller_method(file_object, method_info, progress: progress)
+          when "model" then generator.run_audit_for_model_method(file_object, method_info, progress: progress)
+          when "service" then generator.run_audit_for_service_method(file_object, method_info, progress: progress)
+          else generator.run_audit_for_other_method(file_object, method_info, progress: progress)
+          end
+        else
+          # Test generation mode
+          case type
+          when "controller" then generator.run_for_controller_method(file_object, method_info, progress: progress)
+          when "model" then generator.run_for_model_method(file_object, method_info, progress: progress)
+          when "service" then generator.run_for_service_method(file_object, method_info, progress: progress)
+          else generator.run_for_other_method(file_object, method_info, progress: progress)
+          end
         end
       end
     end

data/lib/tng/services/fix_orchestrator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "repair_service"
+
+module Tng
+  module Services
+    class FixOrchestrator
+      MAX_ITERATIONS = 3
+
+      def initialize(pastel, http_client)
+        @pastel = pastel
+        @repair_service = RepairService.new(http_client)
+      end
+
+      def run(file_path)
+        unless File.exist?(file_path)
+          puts @pastel.red("❌ File not found: #{file_path}")
+          return
+        end
+
+        puts @pastel.bright_white("🔧 Starting Auto-Fix loop for #{file_path}...")
+
+        all_healthy = false
+        MAX_ITERATIONS.times do |i|
+          puts @pastel.dim("\n--- Iteration #{i + 1} ---")
+
+          # 1. Syntax Check
+          status = Tng::Utils.validate_ruby_syntax(file_path)
+          unless status[:success]
+            puts @pastel.yellow("⚠️  Syntax error detected!")
+            apply_fix(file_path, :syntax, status[:output])
+            next
+          end
+          puts @pastel.green("✓ Syntax OK")
+
+          # 2. Rubocop Check
+          status = Tng::Utils.validate_rubocop(file_path)
+          unless status[:success]
+            puts @pastel.yellow("⚠️  Rubocop violations detected!")
+            apply_fix(file_path, :lint, status[:output])
+            next
+          end
+          puts @pastel.green("✓ Rubocop OK")
+
+          # 3. Test Check (Optional/Proactive)
+          status = Tng::Utils.run_tests(file_path)
+          unless status[:success]
+            puts @pastel.yellow("⚠️  Test failures detected!")
+            apply_fix(file_path, :runtime, status[:output])
+            next
+          end
+          puts @pastel.green("✓ Tests Passed")
+
+          all_healthy = true
+          break
+        end
+
+        if all_healthy
+          puts @pastel.bright_green("\n🎉 All checks passed! File is healthy.")
+        else
+          puts @pastel.red("\n❌ Max iterations reached. File still has issues.")
+        end
+      end
+
+      private
+
+      def apply_fix(file_path, error_type, error_message)
+        puts @pastel.blue("🧠 Calling LLM to fix #{error_type}...")
+
+        context = {
+          app_config: Tng::Services::UserAppConfig.config_with_source,
+          test_gems: Tng::Utils.has_gem?("rspec") ? ["rspec"] : ["minitest"] # Basic for now
+        }
+
+        result = @repair_service.repair_file(file_path, error_type, error_message, context)
+
+        if result[:error]
+          puts @pastel.red("❌ Repair failed: #{result[:message]}")
+          return
+        end
+
+        if result["file_content"]
+          File.write(file_path, result["file_content"])
+          puts @pastel.green("✅ Fix applied: #{result["applied_fixes"]&.join(", ")}")
+          puts @pastel.dim("📝 Explanation: #{result["explanation"]}")
+        else
+          puts @pastel.yellow("⚠️  LLM did not return file content.")
+        end
+      end
+    end
+  end
+end

data/lib/tng/services/repair_service.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "json"
+
+module Tng
+  module Services
+    class RepairService
+      REPAIR_PATH = "cli/tng_rails/contents/repair"
+
+      def initialize(http_client)
+        @http_client = http_client
+      end
+
+      def repair_file(file_path, error_type, error_message, context_info = {})
+        file_content = File.read(file_path)
+
+        payload = {
+          file_path: file_path,
+          file_content: file_content,
+          error_type: error_type,
+          error_message: error_message,
+          context_info: context_info
+        }
+
+        # Compress payload
+        json_payload = payload.to_json
+        compressed_payload = Zlib::Deflate.deflate(json_payload)
+
+        response = @http_client.post_binary(REPAIR_PATH, compressed_payload)
+
+        return { error: :network_error, message: "Network error" } if response.is_a?(HTTPX::ErrorResponse)
+        return { error: :auth_failed, message: "Auth failed" } if [401, 403].include?(response.status)
+
+        begin
+          data = JSON.parse(response.body)
+          if data["error"]
+            { error: :server_error, message: data["error"] }
+          else
+            data["result"] # This contains { file_content, explanation, applied_fixes }
+          end
+        rescue JSON::ParserError => e
+          { error: :parse_error, message: "Failed to parse repair response: #{e.message}" }
+        end
+      end
+    end
+  end
+end

data/lib/tng/services/test_generator.rb

@@ -36,6 +36,70 @@ module Tng
         generate_test_for_type(other_file, method_info, :other, progress: progress)
       end
 
+      # Audit mode - async, polls for completion
+      def run_audit_for_controller_method(controller, method_info, progress: nil)
+        run_audit_for_type(controller, method_info, :controller, progress: progress)
+      end
+
+      def run_audit_for_model_method(model, method_info, progress: nil)
+        run_audit_for_type(model, method_info, :model, progress: progress)
+      end
+
+      def run_audit_for_service_method(service, method_info, progress: nil)
+        run_audit_for_type(service, method_info, :service, progress: progress)
+      end
+
+      def run_audit_for_other_method(other_file, method_info, progress: nil)
+        run_audit_for_type(other_file, method_info, :other, progress: progress)
+      end
+
+      def run_audit_for_type(file_object, method_info, type, progress: nil)
+        response = send_audit_request_for_type(file_object, method_info, type)
+        return { error: :network_error, message: "Network error" } unless response
+
+        if response.is_a?(HTTPX::ErrorResponse)
+          return { error: :network_error, message: response.error&.message || "Network error" }
+        end
+
+        return { error: :auth_failed, message: "Invalid or missing API key" } if response.status == 401
+        return { error: :auth_failed, message: "API key expired" } if response.status == 403
+
+        begin
+          job_data = JSON.parse(response.body)
+          return { error: :server_error, message: job_data["error"] } if job_data["error"]
+
+          job_id = job_data["job_id"]
+          return { error: :server_error, message: "No job_id returned" } unless job_id
+
+          # Poll for completion (similar to test generation)
+          result = poll_for_completion(job_id, progress: progress)
+          return { error: :timeout, message: "Audit timed out" } unless result
+
+          # Audit results come back as the result directly (not wrapped)
+          # Wrap in audit_results key for save_audit_file compatibility
+          { audit_results: result }
+        rescue JSON::ParserError => e
+          { error: :parse_error, message: "Failed to parse audit response: #{e.message}" }
+        end
+      end
+
+      def send_audit_request_for_type(file_object, method_info, type)
+        config = request_config
+        name = file_object[:name] || File.basename(file_object[:path], ".rb")
+
+        # Pass audit_mode: true as 8th parameter
+        case type
+        when :controller
+          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, true)
+        when :model
+          Tng.send_request_for_model(name, file_object[:path], method_info, *config, true)
+        when :service
+          Tng.send_request_for_service(name, file_object[:path], method_info, *config, true)
+        when :other
+          Tng.send_request_for_other(name, file_object[:path], method_info, *config, true)
+        end
+      end
+
       def generate_test_for_type(file_object, method_info, type, progress: nil)
         start_time = Time.now
 
@@ -77,15 +141,16 @@ module Tng
         config = request_config
         name = file_object[:name] || File.basename(file_object[:path], ".rb")
 
+        # Pass audit_mode: false as 8th parameter for normal test generation
         case type
         when :controller
-          Tng.send_request_for_controller(name, file_object[:path], method_info, *config)
+          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, false)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config)
+          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config)
+          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config)
+          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false)
         end
       end
 
@@ -98,6 +163,7 @@ module Tng
         ]
       end
 
+      # Modified method signature and added interrupt handler
       def poll_for_completion(job_id, progress: nil)
         start_time = Time.current
         attempts = 0
@@ -229,10 +295,26 @@ module Tng
               next
             end
           rescue JSON::ParserError => e
-            debug_log("Failed to parse response status: #{e.message}") if debug_enabled?
+            debug_log("JSON parse error: #{e.message}") if debug_enabled?
             next
           end
         end
+      rescue Interrupt
+        # User pressed Ctrl+C - exit gracefully
+        system("clear") || system("cls")
+        puts "\n\n#{TTY::Box.frame(
+          "Generation cancelled by user",
+          padding: 1,
+          align: :center,
+          border: :thick,
+          style: {
+            fg: :yellow,
+            border: {
+              fg: :yellow
+            }
+          }
+        )}"
+        exit(0)
       end
 
       def trigger_cleanup(job_id)

data/lib/tng/ui/go_ui_session.rb

@@ -47,14 +47,15 @@ module Tng
       end
 
       # Show test type selection menu
+      # @param mode [String] "test" or "audit" (default: "test")
       # Returns: "controller", "model", "service", "other", "back"
-      def show_test_type_menu
+      def show_test_type_menu(mode = "test")
         output_file = Tempfile.new(["go_ui_test_type", ".json"])
         output_path = output_file.path
         output_file.close
 
         begin
-          system(@binary_path, "rails-test-menu", "--output", output_path)
+          system(@binary_path, "rails-test-menu", "--output", output_path, "--mode", mode)
 
           return "back" unless File.exist?(output_path) && File.size(output_path) > 0
 
@@ -92,7 +93,7 @@ module Tng
       # @param message [String] Spinner message
       # @yield Block that returns Hash with :success and :message keys
       # @return [Hash] Result from block
-      def show_spinner(message, &block)
+      def show_spinner(message)
         control_file = Tempfile.new(["go_ui_spinner", ".json"])
         control_path = control_file.path
         control_file.close
@@ -126,7 +127,7 @@ module Tng
       # @param title [String] Progress title
       # @yield [ProgressUpdater] Block receives updater and returns Hash with :message and :result
       # @return [Hash] Result from block
-      def show_progress(title, &block)
+      def show_progress(title)
         control_file = Tempfile.new(["go_ui_progress", ".json"])
         control_path = control_file.path
         control_file.close
@@ -239,6 +240,28 @@ module Tng
         puts "Test results error: #{e.message}"
       end
 
+      # Show audit results
+      # @param audit_result [Hash] Full audit result with items, method_name, class_name, method_source_with_lines
+      # @param audit_type [String] "issues" or "behaviours"
+      def show_audit_results(audit_result, _audit_type)
+        # Always use the unified audit-results command which handles both issues and behaviours
+        command = "audit-results"
+
+        # Send full result object via temp file to avoid CLI argument limits
+        data_json = JSON.generate(audit_result)
+
+        input_file = Tempfile.new(["go_ui_audit", ".json"])
+        input_path = input_file.path
+        File.write(input_path, data_json)
+        input_file.close
+
+        system(@binary_path, command, "--file", input_path)
+      rescue StandardError => e
+        puts "Audit results error: #{e.message}"
+      ensure
+        File.unlink(input_path) if input_path && File.exist?(input_path)
+      end
+
       # Show authentication error
       # @param message [String] Error message to display
       def show_auth_error(message = "Authentication failed")

data/lib/tng/ui/json_session.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Tng
+  module UI
+    # UI Session that outputs JSON events to STDOUT for machine consumption
+    class JsonSession
+      def initialize
+        # Ensure stdout is sync so events are emitted immediately
+        $stdout.sync = true
+        @running = false
+      end
+
+      def start
+        @running = true
+        emit_event("started", { message: "TNG JSON Session Started" })
+      end
+
+      def stop
+        @running = false
+        emit_event("stopped", { message: "TNG JSON Session Stopped" })
+      end
+
+      def display_error(message)
+        emit_event("error", { message: strip_colors(message) })
+      end
+
+      def display_warning(message)
+        emit_event("warning", { message: strip_colors(message) })
+      end
+
+      def display_info(message)
+        emit_event("info", { message: strip_colors(message) })
+      end
+
+      def display_list(title, items)
+        emit_event("list", { title: strip_colors(title), items: items })
+      end
+
+      def running?
+        @running
+      end
+
+      # ------------------------------------------------------------------
+      # Progress & Spinners
+      # ------------------------------------------------------------------
+
+      def show_spinner(message)
+        emit_event("progress", { message: message, status: "running" })
+
+        result = yield
+
+        status = result&.dig(:success) ? "success" : "error"
+        emit_event("progress", {
+                     message: result&.dig(:message) || "Done",
+                     status: status
+                   })
+
+        result
+      rescue StandardError => e
+        emit_event("error", { message: e.message })
+        raise
+      end
+
+      def show_progress(title)
+        emit_event("progress_start", { title: title })
+
+        reporter = JsonProgressReporter.new
+        result = yield(reporter)
+
+        if result&.dig(:error)
+          # Error handled by reporter or caller
+        else
+          emit_event("progress_complete", {
+                       message: result&.dig(:message) || "Done",
+                       result: result
+                     })
+        end
+
+        result
+      rescue StandardError => e
+        emit_event("error", { message: e.message })
+        raise
+      end
+
+      # ------------------------------------------------------------------
+      # Results Display
+      # ------------------------------------------------------------------
+
+      def show_audit_results(audit_result, _audit_type)
+        emit_event("result", audit_result)
+      end
+
+      def show_test_results(title, passed, failed, errors, total, results = [])
+        emit_event("test_results", {
+                     title: title,
+                     passed: passed,
+                     failed: failed,
+                     errors: errors,
+                     total: total,
+                     results: results
+                   })
+      end
+
+      # ------------------------------------------------------------------
+      # Errors & Warnings
+      # ------------------------------------------------------------------
+
+      def show_auth_error(message = "Authentication failed")
+        emit_event("auth_error", { message: message })
+      end
+
+      def show_config_error(missing)
+        emit_event("config_error", { missing: missing })
+      end
+
+      def show_config_missing(missing_items)
+        emit_event("config_missing", { missing: missing_items })
+      end
+
+      def show_system_status(status)
+        emit_event("system_status", status)
+      end
+
+      # ------------------------------------------------------------------
+      # Stubs for Interactive Methods (Not supported in JSON mode)
+      # ------------------------------------------------------------------
+
+      def show_menu
+        # JSON mode is non-interactive usually, but if called, we just exit
+        "exit"
+      end
+
+      def show_test_type_menu(_mode = "test")
+        "back"
+      end
+
+      def show_list_view(_title, _items)
+        "back"
+      end
+
+      def show_post_generation_menu(_file_path, _run_command)
+        "back"
+      end
+
+      def show_auth_warning(missing_items = "")
+        emit_event("auth_warning", { missing: missing_items })
+        # In headless mode, we probably can't prompt, so we might default to cancel
+        # or we could make this configurable. For now, cancel to be safe.
+        "cancel"
+      end
+
+      def show_banner(_version); end
+      def show_goodbye; end
+      def show_post_install(_version); end
+      def show_help(_version); end
+      def show_stats(_stats); end
+      def show_clipboard_success(_cmd); end
+
+      def show_no_items(type)
+        emit_event("no_items", { type: type })
+      end
+
+      private
+
+      def strip_colors(str)
+        str.gsub(/\e\[\d+(;\d+)*m/, "")
+      end
+
+      def emit_event(type, data = {})
+        puts JSON.generate({ type: type }.merge(data))
+      end
+    end
+
+    class JsonProgressReporter
+      def initialize
+        @step = 0
+      end
+
+      def update(message, percent = nil, step_increment: true, explicit_step: nil)
+        step_idx = explicit_step || @step
+
+        payload = { type: "progress_update", message: message }
+        payload[:percent] = percent if percent
+        payload[:step] = step_idx
+
+        puts JSON.generate(payload)
+
+        @step += 1 if step_increment && explicit_step.nil?
+      end
+
+      def error(message)
+        puts JSON.generate({ type: "error", message: message })
+      end
+    end
+  end
+end