tng 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbf8e76f0412c426150b5a9cef4d3a077d9747bf02c16ea6086f621cb78236a0
-  data.tar.gz: 5bb42890de6580034ffc78df9b699433667e07e7877c7dc280ca53d998fa29cf
+  metadata.gz: 8caa50f15bf264b0c8c1ec375469881d00c1137385f127c28c1e4a8a18bb9554
+  data.tar.gz: 56c8dde536a3b54f1e8d0020aae0093b9014b749af79511df5903f920f66c6dd
 SHA512:
-  metadata.gz: 868acc7d7fa9b539fac0b9906662cdf906a115da97f86643f8d2c88f9015b536e3ec75bbb50537df0a2283232207d7531a12b81eb8af4bdc8a1aa4abb4a83122
-  data.tar.gz: 1410ad3af1e8b0bfbfa7d9849ba293cddca599e4dfda976f6433651814343592e39ef40aec5ca7c884e4ad28f004ab86bd36a384e1c334ab008629bec9ea3bd5
+  metadata.gz: 185d1c9670f66fdd3eb2f469c5109bbdf04c8ca2157c9de3983cd332972dc30c8038926b95013a8a1a2bc6b21d12be9a3f8efb060787936a97202bc0d526d8a1
+  data.tar.gz: 4374f5134a64c7b3c5c3d0b4a9b4bd785c555b0932a7552d285b0aa74ebadd1745a7b0395dcaef257426cbbc3e5328d2ca026fa9650d78147cbd4d5c48971801

data/bin/tng

@@ -10,6 +10,7 @@ require "tng"
 require "tng/services/direct_generation"
 require "tng/services/extract_methods"
 require "tng/services/file_type_detector"
+require "tng/services/fix_orchestrator"
 
 require "tty-screen"
 require "tty-option"
@@ -57,6 +58,18 @@ class CLI
     desc "Method name (for per-method tests)"
   end
 
+  flag :audit do
+    short "-a"
+    long "--audit"
+    desc "Run in audit mode (find issues and behaviours instead of generating tests)"
+  end
+
+  flag :fix do
+    short "-x"
+    long "--fix"
+    desc "Run in fix mode (automatically repair syntax, lint, and test errors)"
+  end
+
   flag :help do
     short "-h"
     long "--help"
@@ -90,7 +103,9 @@ class CLI
 
     initialize_config_and_clients if rails_loaded
 
-    if params[:file]
+    if params[:fix]
+      handle_fix_command
+    elsif params[:file]
       run_direct_generation
     else
       if find_rails_root && !rails_loaded && !defined?(Rails)
@@ -121,6 +136,10 @@ class CLI
         normalized << "--file=#{::Regexp.last_match(2)}"
       when /^(?:--)?(method|m)=(.+)$/
         normalized << "--method=#{::Regexp.last_match(2)}"
+      when /^(?:--)?(audit|a)$/
+        normalized << "--audit"
+      when /^(?:--)?(fix|x)$/
+        normalized << "--fix"
       when /^(help|h)=(.+)$/
         normalized << "--help=#{::Regexp.last_match(2)}"
       when /^--file$/, /^-f$/
@@ -151,8 +170,11 @@ class CLI
       arg = positional_args[0]
       has_file = normalized.any? { |a| a.match?(/^--file/) }
       has_method = normalized.any? { |a| a.match?(/^--method/) }
+      has_fix = normalized.any? { |a| a.match?(/^--fix/) }
 
-      if !has_file && (arg.end_with?(".rb") || arg.include?("/"))
+      if has_fix && !has_file
+        normalized << "--file=#{arg}"
+      elsif !has_file && (arg.end_with?(".rb") || arg.include?("/"))
         normalized << "--file=#{arg}"
       elsif !has_method && !arg.include?("/")
         normalized << "--method=#{arg}"
@@ -171,6 +193,8 @@ class CLI
       case choice
       when "tests"
         handle_test_generation
+      when "audit"
+        handle_audit_method
       when "stats"
         user_stats
       when "about"
@@ -201,6 +225,332 @@ class CLI
     end
   end
 
+  def handle_audit_method
+    choice = @go_ui.show_test_type_menu("audit")
+
+    case choice
+    when "controller"
+      audit_controller_method
+    when "model"
+      audit_model_method
+    when "service"
+      audit_service_method
+    when "other"
+      audit_other_method
+    end
+  end
+
+  def audit_controller_method
+    controllers = nil
+
+    @go_ui.show_spinner("Analyzing controllers...") do
+      controllers = Tng::Analyzers::Controller.files_in_dir("app/controllers").map do |file|
+        relative_path = file[:path].gsub(%r{^.*app/controllers/}, "").gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+        { name: namespaced_name, path: file[:path] }
+      end
+      { success: true, message: "Found #{controllers.length} controllers" }
+    end
+
+    if controllers.empty?
+      @go_ui.show_no_items("controllers")
+      return
+    end
+
+    items = controllers.map { |c| { name: c[:name], path: c[:path] } }
+
+    loop do
+      selected_name = @go_ui.show_list_view("Select Controller to Audit", items)
+      return if selected_name == "back"
+
+      controller_choice = controllers.find { |c| c[:name] == selected_name }
+      next unless controller_choice
+
+      show_controller_audit_method_selection(controller_choice)
+      # If we return here, it means user pressed back from method selection
+      # Loop will show controller list again
+    end
+  end
+
+  def show_controller_audit_method_selection(controller)
+    methods = extract_controller_methods(controller)
+
+    if methods.empty?
+      @go_ui.show_no_items("methods in #{controller[:name]}")
+      return
+    end
+
+    items = methods.map { |m| { name: m[:name], path: controller[:name] } }
+    selected_name = @go_ui.show_list_view("Select Method to Audit", items)
+    return if selected_name == "back"
+
+    method_choice = methods.find { |m| m[:name] == selected_name }
+    return unless method_choice
+
+    run_audit_for_controller_method(controller, method_choice)
+  end
+
+  def run_audit_for_controller_method(controller, method_info)
+    result = nil
+
+    @go_ui.show_progress("Auditing #{controller[:name]}##{method_info[:name]}") do |progress|
+      progress.update("Analyzing method context...", 25)
+      progress.update("Running logical analysis...", 50)
+      progress.update("Detecting issues and behaviours...", 75)
+
+      result = Tng::Services::TestGenerator.new(@http_client).run_audit_for_controller_method(
+        controller, method_info, progress: progress
+      )
+
+      progress.update("Processing results...", 100)
+
+      if result&.dig(:error)
+        { message: result[:message] || "Audit failed", error: result[:error] }
+      else
+        { message: "Audit complete!" }
+      end
+    end
+
+    return @go_ui.show_auth_error(result[:message] || "Audit failed") if result&.dig(:error)
+
+    display_audit_results(result)
+  end
+
+  def display_audit_results(result)
+    audit_data = result[:audit_results]
+
+    # Save to JSON for persistence
+    File.write("audit.json", JSON.pretty_generate(audit_data))
+    puts @pastel.green("💾 Audit results saved to audit.json")
+
+    # Send entire audit_data to go-ui (includes issues, behaviours, method_name, class_name, method_source_with_lines)
+    @go_ui.show_audit_results(audit_data, "issues")
+  end
+
+  # Placeholder methods for other component types
+  def audit_model_method
+    models = nil
+
+    @go_ui.show_spinner("Analyzing models...") do
+      models = Tng::Analyzers::Model.files_in_dir("app/models").map do |file|
+        relative_path = file[:path].gsub(%r{^.*app/models/}, "").gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+        { name: namespaced_name, path: file[:path] }
+      end
+      { success: true, message: "Found #{models.length} models" }
+    end
+
+    if models.empty?
+      @go_ui.show_no_items("models")
+      return
+    end
+
+    items = models.map { |m| { name: m[:name], path: m[:path] } }
+
+    loop do
+      selected_name = @go_ui.show_list_view("Select Model to Audit", items)
+      return if selected_name == "back"
+
+      model_choice = models.find { |m| m[:name] == selected_name }
+      next unless model_choice
+
+      show_model_audit_method_selection(model_choice)
+    end
+  end
+
+  def show_model_audit_method_selection(model)
+    methods = extract_model_methods(model)
+
+    if methods.empty?
+      @go_ui.show_no_items("methods in #{model[:name]}")
+      return
+    end
+
+    items = methods.map { |m| { name: m[:name], path: model[:name] } }
+    selected_name = @go_ui.show_list_view("Select Method to Audit", items)
+    return if selected_name == "back"
+
+    method_choice = methods.find { |m| m[:name] == selected_name }
+    return unless method_choice
+
+    run_audit_for_model_method(model, method_choice)
+  end
+
+  def run_audit_for_model_method(model, method_info)
+    result = nil
+
+    @go_ui.show_progress("Auditing #{model[:name]}##{method_info[:name]}") do |progress|
+      progress.update("Parsing method details...", 25)
+      progress.update("Analyzing method context...", 25)
+      progress.update("Running logical analysis...", 50)
+      progress.update("Detecting issues and behaviours...", 75)
+
+      result = Tng::Services::TestGenerator.new(@http_client).run_audit_for_model_method(
+        model, method_info, progress: progress
+      )
+
+      progress.update("Processing results...", 100)
+
+      if result&.dig(:error)
+        { message: result[:message] || "Audit failed", error: result[:error] }
+      else
+        { message: "Audit complete!" }
+      end
+    end
+
+    return @go_ui.show_auth_error(result[:message] || "Audit failed") if result&.dig(:error)
+
+    display_audit_results(result)
+  end
+
+  def audit_service_method
+    services = nil
+
+    @go_ui.show_spinner("Analyzing services...") do
+      services = Tng::Analyzers::Service.files_in_dir.map do |file|
+        relative_path = file[:path].gsub(%r{^.*app/services?/}, "").gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+        { name: namespaced_name, path: file[:path] }
+      end
+      { success: true, message: "Found #{services.length} services" }
+    end
+
+    if services.empty?
+      @go_ui.show_no_items("services")
+      return
+    end
+
+    items = services.map { |s| { name: s[:name], path: s[:path] } }
+
+    loop do
+      selected_name = @go_ui.show_list_view("Select Service to Audit", items)
+      return if selected_name == "back"
+
+      service_choice = services.find { |s| s[:name] == selected_name }
+      next unless service_choice
+
+      show_service_audit_method_selection(service_choice)
+    end
+  end
+
+  def show_service_audit_method_selection(service)
+    methods = extract_service_methods(service)
+
+    if methods.empty?
+      @go_ui.show_no_items("methods in #{service[:name]}")
+      return
+    end
+
+    items = methods.map { |m| { name: m[:name], path: service[:name] } }
+    selected_name = @go_ui.show_list_view("Select Method to Audit", items)
+    return if selected_name == "back"
+
+    method_choice = methods.find { |m| m[:name] == selected_name }
+    return unless method_choice
+
+    run_audit_for_service_method(service, method_choice)
+  end
+
+  def run_audit_for_service_method(service, method_info)
+    result = nil
+
+    @go_ui.show_progress("Auditing #{service[:name]}##{method_info[:name]}") do |progress|
+      progress.update("Parsing method details...", 25)
+      progress.update("Analyzing method context...", 25)
+      progress.update("Running logical analysis...", 50)
+      progress.update("Detecting issues and behaviours...", 75)
+
+      result = Tng::Services::TestGenerator.new(@http_client).run_audit_for_service_method(
+        service, method_info, progress: progress
+      )
+
+      progress.update("Processing results...", 100)
+
+      if result&.dig(:error)
+        { message: result[:message] || "Audit failed", error: result[:error] }
+      else
+        { message: "Audit complete!" }
+      end
+    end
+
+    return @go_ui.show_auth_error(result[:message] || "Audit failed") if result&.dig(:error)
+
+    display_audit_results(result)
+  end
+
+  def audit_other_method
+    other_files = nil
+
+    @go_ui.show_spinner("Analyzing other files...") do
+      other_files = Tng::Analyzers::Other.files_in_dir.map do |file|
+        relative_path = file[:relative_path].gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+
+        { name: namespaced_name, path: file[:path], type: file[:type] }
+      end
+      { success: true, message: "Found #{other_files.length} other files" }
+    end
+
+    if other_files.empty?
+      @go_ui.show_no_items("other files")
+      return
+    end
+
+    items = other_files.map { |f| { name: f[:name], path: f[:path] } }
+    selected_name = @go_ui.show_list_view("Select File", items)
+    return if selected_name == "back"
+
+    other_choice = other_files.find { |f| f[:name] == selected_name }
+    return unless other_choice
+
+    show_audit_other_method_selection(other_choice)
+  end
+
+  def show_audit_other_method_selection(other_file)
+    methods = extract_other_methods(other_file)
+
+    if methods.empty?
+      @go_ui.show_no_items("methods in #{other_file[:name]}")
+      return
+    end
+
+    items = methods.map { |m| { name: m[:name], path: other_file[:name] } }
+    selected_name = @go_ui.show_list_view("Audit Method in #{other_file[:name]}", items)
+    return if selected_name == "back"
+
+    method_choice = methods.find { |m| m[:name] == selected_name }
+    return unless method_choice
+
+    run_audit_for_other_method(other_file, method_choice)
+  end
+
+  def run_audit_for_other_method(other_file, method_info)
+    result = nil
+
+    @go_ui.show_progress("Auditing #{other_file[:name]}##{method_info[:name]}") do |progress|
+      progress.update("Parsing method details...", 25)
+      progress.update("Analyzing method context...", 25)
+      progress.update("Running logical analysis...", 50)
+      progress.update("Detecting issues and behaviours...", 75)
+
+      result = Tng::Services::TestGenerator.new(@http_client).run_audit_for_other_method(
+        other_file, method_info, progress: progress
+      )
+
+      progress.update("Processing results...", 100)
+
+      if result&.dig(:error)
+        { message: result[:message] || "Audit failed", error: result[:error] }
+      else
+        { message: "Audit complete!" }
+      end
+    end
+
+    return @go_ui.show_auth_error(result[:message] || "Audit failed") if result&.dig(:error)
+
+    display_audit_results(result)
+  end
+
   def generate_controller_tests
     controllers = nil
 
@@ -220,13 +570,16 @@ class CLI
     end
 
     items = controllers.map { |c| { name: c[:name], path: c[:path] } }
-    selected_name = @go_ui.show_list_view("Select Controller", items)
-    return if selected_name == "back"
 
-    controller_choice = controllers.find { |c| c[:name] == selected_name }
-    return unless controller_choice
+    loop do
+      selected_name = @go_ui.show_list_view("Select Controller", items)
+      return if selected_name == "back"
+
+      controller_choice = controllers.find { |c| c[:name] == selected_name }
+      next unless controller_choice
 
-    show_controller_test_options(controller_choice)
+      show_controller_test_options(controller_choice)
+    end
   end
 
   def generate_model_tests
@@ -248,13 +601,16 @@ class CLI
     end
 
     items = models.map { |m| { name: m[:name], path: m[:path] } }
-    selected_name = @go_ui.show_list_view("Select Model", items)
-    return if selected_name == "back"
 
-    model_choice = models.find { |m| m[:name] == selected_name }
-    return unless model_choice
+    loop do
+      selected_name = @go_ui.show_list_view("Select Model", items)
+      return if selected_name == "back"
+
+      model_choice = models.find { |m| m[:name] == selected_name }
+      next unless model_choice
 
-    show_model_test_options(model_choice)
+      show_model_test_options(model_choice)
+    end
   end
 
   def generate_service_tests
@@ -276,13 +632,16 @@ class CLI
     end
 
     items = services.map { |s| { name: s[:name], path: s[:path] } }
-    selected_name = @go_ui.show_list_view("Select Service", items)
-    return if selected_name == "back"
 
-    service_choice = services.find { |s| s[:name] == selected_name }
-    return unless service_choice
+    loop do
+      selected_name = @go_ui.show_list_view("Select Service", items)
+      return if selected_name == "back"
 
-    show_service_test_options(service_choice)
+      service_choice = services.find { |s| s[:name] == selected_name }
+      next unless service_choice
+
+      show_service_test_options(service_choice)
+    end
   end
 
   def generate_other_tests
@@ -623,7 +982,8 @@ class CLI
       @testng,
       @http_client,
       params,
-      method(:show_post_generation_menu)
+      method(:show_post_generation_menu),
+      @go_ui
     )
 
     direct_generator.run
@@ -688,6 +1048,18 @@ class CLI
     )
     @testng = Services::Testng.new(@http_client)
   end
+
+  def handle_fix_command
+    file_path = params[:file]
+    unless file_path
+      puts @pastel.red("❌ File parameter is required for fix mode")
+      puts @pastel.yellow("Usage: bundle exec tng --fix --file=your_file.rb")
+      return
+    end
+
+    orchestrator = Tng::Services::FixOrchestrator.new(@pastel, @http_client)
+    orchestrator.run(file_path)
+  end
 end
 
 cli = CLI.new

data/lib/tng/services/direct_generation.rb

@@ -8,16 +8,29 @@ 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")
@@ -42,7 +55,7 @@ module Tng
       private
 
       def suggest_similar_files(file_path)
-        base_name = File.basename(file_path, '.rb')
+        base_name = File.basename(file_path, ".rb")
         puts @pastel.yellow("💡 Did you mean one of these?")
 
         similar_files = find_similar_files(base_name)
@@ -61,8 +74,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
 
@@ -87,11 +100,17 @@ module Tng
           return
         end
 
-        puts @pastel.bright_white("🎯 Generating test for #{file_object[:name]}##{method_info[:name]}...")
+        puts @pastel.bright_white("🎯 #{@params[:audit] ? "Auditing" : "Generating test for"} #{file_object[:name]}##{method_info[:name]}...")
 
         result = generate_test_result(file_object, method_info, type)
 
-        if result && result[:file_path]
+        if result&.dig(:error)
+          puts @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")
@@ -110,11 +129,20 @@ module Tng
       def generate_test_result(file_object, method_info, type)
         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)
+          else { error: :unsupported, message: "Audit mode only supports controllers currently" }
+          end
+        else
+          # Test generation mode
+          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)
+          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/utils.rb

@@ -287,7 +287,7 @@ module Tng
       end
     end
 
-    private_class_method def self.count_test_nodes(node)
+    def self.count_test_nodes(node)
       return 0 unless node.respond_to?(:child_nodes)
 
       count = 0
@@ -303,7 +303,7 @@ module Tng
       count
     end
 
-    private_class_method def self.test_node?(node)
+    def self.test_node?(node)
       case node
       when Prism::DefNode
         # Minitest: def test_something
@@ -456,5 +456,28 @@ module Tng
         "#{minutes}m #{remaining_seconds}s"
       end
     end
+
+    def self.validate_ruby_syntax(file_path)
+      output = `ruby -c #{file_path} 2>&1`
+      { success: $?.success?, output: output }
+    end
+
+    def self.validate_rubocop(file_path)
+      # Run rubocop with JSON output
+      output = `bundle exec rubocop #{file_path} --format json 2>&1`
+      { success: $?.success?, output: output }
+    rescue StandardError => e
+      { success: false, output: "Rubocop error: #{e.message}" }
+    end
+
+    def self.run_tests(file_path)
+      command = if file_path.include?("/spec/")
+                  "bundle exec rspec #{file_path}"
+                else
+                  "bundle exec rails test #{file_path}"
+                end
+      output = `#{command} 2>&1`
+      { success: $?.success?, output: output, command: command }
+    end
   end
 end

data/lib/tng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tng
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tng
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - ralucab
@@ -176,6 +176,8 @@ files:
 - lib/tng/services/direct_generation.rb
 - lib/tng/services/extract_methods.rb
 - lib/tng/services/file_type_detector.rb
+- lib/tng/services/fix_orchestrator.rb
+- lib/tng/services/repair_service.rb
 - lib/tng/services/test_generator.rb
 - lib/tng/services/testng.rb
 - lib/tng/services/user_app_config.rb
@@ -217,7 +219,7 @@ post_install_message: "┌ TNG ────────────────
   \                                                            │\n│  • bundle exec
   tng --help  - Show help information                 │\n│                                                                    │\n│
   \ \U0001F4A1 Generate tests for individual methods with precision            │\n└────────────────────────────────────────────────────────────
-  v0.3.8 ┘\n"
+  v0.3.9 ┘\n"
 rdoc_options: []
 require_paths:
 - lib