tng 0.4.7 → 0.4.9

data/Rakefile

@@ -75,9 +75,17 @@ task :redo do
       # Code sign the bundles on macOS
       if RUBY_PLATFORM.include?("darwin")
         puts "🔐 Signing bundles..."
+        system("xattr -dr com.apple.quarantine binaries/ || true")
+
+        # Sign tng bundle
         system("codesign --force --sign - #{source_file}")
         system("codesign --force --sign - #{File.join(destination_dir, binary_name)}")
 
+        # Sign go-ui binaries if present
+        Dir.glob("binaries/go-ui-darwin-*").each do |binary|
+          system("codesign --force --sign - #{binary}")
+        end
+
         # Also sign the gem installation if it exists
         ruby_version = RUBY_VERSION.split(".")[0..1].join(".")
         gem_bundle = File.expand_path("~/.local/share/mise/installs/ruby/#{RUBY_VERSION}/lib/ruby/gems/#{ruby_version}.0/gems/tng-*/binaries/tng.bundle")

data/bin/tng

@@ -48,6 +48,14 @@ class CLI
     example "Duplicate Detection:", ""
     example "  bundle exec tng app/services/pricing_service.rb --clones", ""
     example "  bundle exec tng --file=users_controller.rb --clones --level=2", ""
+    example ""
+    example "Dead Code Detection:", ""
+    example "  bundle exec tng app/models/user.rb --deadcode", ""
+    example "  bundle exec tng --file=app/services/auth_service.rb -d", ""
+    example ""
+    example "X-Ray Visualization:", ""
+    example "  bundle exec tng app/services/payment_processor.rb process_payment --xray", ""
+    example "  bundle exec tng --file=users_controller.rb --method=create --xray --json", ""
   end
 
   option :file do
@@ -68,10 +76,16 @@ class CLI
     desc "Run in clone detection mode (find code duplication)"
   end
 
+  flag :deadcode do
+    short "-d"
+    long "--deadcode"
+    desc "Run in dead code detection mode (unreachable code, unused variables)"
+  end
+
   option :level do
     short "-l"
     long "--level=LEVEL"
-    desc "Analysis level: 1 (Token), 2 (Structural), all (Both)"
+    desc "Analysis level: 1 (Token), 2 (Structural), 3 (Fuzzy), all (All levels)"
   end
 
   flag :audit do
@@ -85,6 +99,11 @@ class CLI
     desc "Generate and visualize a symbolic trace"
   end
 
+  flag :xray do
+    long "--xray"
+    desc "Generate X-Ray visualization (Mermaid flowchart)"
+  end
+
   flag :json do
     short "-j"
     long "--json"
@@ -140,6 +159,10 @@ class CLI
       handle_fix_command
     elsif params[:trace] && params[:file]
       run_direct_trace
+    elsif params[:deadcode] && params[:file]
+      run_dead_code_detection
+    elsif params[:xray] && params[:file]
+      run_direct_xray
     elsif params[:file]
       run_direct_generation
     else
@@ -153,7 +176,10 @@ class CLI
       return unless check_configuration
 
       check_system_status
+      # puts "DEBUG: Verifying authentication..."
       return unless check_authentication
+      # puts "DEBUG: Authentication verified."
+
 
       clear_screen
       @go_ui.show_banner(Tng::VERSION)
@@ -175,12 +201,16 @@ class CLI
         normalized << "--audit"
       when /^(?:--)?(trace)$/
         normalized << "--trace"
+      when /^(?:--)?(xray)$/
+        normalized << "--xray"
       when /^(?:--)?(json|j)$/
         normalized << "--json"
       when /^(?:--)?(fix|x)$/
         normalized << "--fix"
       when /^(?:--)?(clones|c)$/
         normalized << "--clones"
+      when /^(?:--)?(deadcode|d)$/
+        normalized << "--deadcode"
       when /^(?:--)?(level|l)=(.+)$/
         normalized << "--level=#{::Regexp.last_match(2)}"
       when /^(help|h)=(.+)$/
@@ -240,8 +270,12 @@ class CLI
         handle_audit_method
       when "trace"
         handle_trace_method
+      when "xray"
+        handle_xray_method
       when "clones"
         handle_clone_detection
+      when "deadcode"
+        handle_dead_code_detection_menu
       when "stats"
         user_stats
       when "about"
@@ -506,6 +540,30 @@ class CLI
     @go_ui.show_audit_results(audit_data, "issues")
   end
 
+  def run_dead_code_detection
+    file_path = params[:file]
+    unless File.exist?(file_path)
+      puts @pastel.red("Error: File '#{file_path}' not found.")
+      return
+    end
+
+    absolute_path = File.expand_path(file_path)
+
+    begin
+      # Always get JSON from Rust for flexibility
+      result = Tng.detect_dead_code(absolute_path, true)
+
+      if @go_ui
+        @go_ui.show_dead_code_results(absolute_path, result)
+      else
+        # Fallback to text output
+        puts Tng.detect_dead_code(absolute_path, false)
+      end
+    rescue => e
+      puts @pastel.red("Error detecting dead code: #{e.message}")
+    end
+  end
+
   # Placeholder methods for other component types
   def audit_model_method
     models = nil
@@ -1169,13 +1227,18 @@ class CLI
   end
 
   def show_post_generation_menu(result)
+    if @go_ui.is_a?(Tng::UI::JsonSession)
+      @go_ui.show_generation_result(result)
+      return
+    end
+
     is_direct_mode = params[:file]
 
     # Direct mode - just print info and exit
     if is_direct_mode
       puts "\n🚀 Test Generated Successfully!"
       puts "📁 File: #{result[:file_path]}"
-      puts "▶️  Run: #{result[:run_command]}"
+      puts "▶\u{fe0f}  Run: #{result[:run_command]}"
       puts "✅ Test generation completed successfully!"
       return
     end
@@ -1196,19 +1259,19 @@ class CLI
     end
   end
 
-  def copy_to_clipboard(command)
+  def copy_to_clipboard(command, silent: false)
     if RUBY_PLATFORM.include?("darwin")
       IO.popen("pbcopy", "w") { |io| io.print command }
-      @go_ui.show_clipboard_success(command)
+      @go_ui.show_clipboard_success(command) unless silent
     elsif RUBY_PLATFORM.include?("linux")
       begin
         IO.popen("xclip -selection clipboard", "w") { |io| io.print command }
-        @go_ui.show_clipboard_success(command)
+        @go_ui.show_clipboard_success(command) unless silent
       rescue Errno::ENOENT
-        puts "\n📋 Copy this command:\n#{command}\n"
+        puts "\n📋 Copy this command:\n#{command}\n" unless silent
       end
     else
-      puts "\n📋 Copy this command:\n#{command}\n"
+      puts "\n📋 Copy this command:\n#{command}\n" unless silent
     end
   end
 
@@ -1255,6 +1318,21 @@ class CLI
     end
   end
 
+  def handle_xray_method
+    choice = @go_ui.show_test_type_menu("xray")
+
+    case choice
+    when "controller"
+      xray_controller_method
+    when "model"
+      xray_model_method
+    when "service"
+      xray_service_method
+    when "other"
+      xray_other_method
+    end
+  end
+
   def trace_controller_method
     select_controller_and_method("Trace") do |controller, method_info|
       run_trace_for_method(controller, method_info)
@@ -1279,6 +1357,30 @@ class CLI
     end
   end
 
+  def xray_controller_method
+    select_controller_and_method("X-Ray") do |controller, method_info|
+      run_xray_for_method(controller, method_info)
+    end
+  end
+
+  def xray_model_method
+    select_model_and_method("X-Ray") do |model, method_info|
+      run_xray_for_method(model, method_info)
+    end
+  end
+
+  def xray_service_method
+    select_service_and_method("X-Ray") do |service, method_info|
+      run_xray_for_method(service, method_info)
+    end
+  end
+
+  def xray_other_method
+    select_other_and_method("X-Ray") do |file, method_info|
+      run_xray_for_method(file, method_info)
+    end
+  end
+
   def run_trace_for_method(file_info, method_info)
     result_path = nil
 
@@ -1332,6 +1434,68 @@ class CLI
     run_trace_for_method(file_info, method_info)
   end
 
+  def run_direct_xray
+    return unless check_configuration
+
+    return unless check_authentication_configuration
+
+    file_path = params[:file]
+    method_name = params[:method]
+
+    unless method_name
+       puts @pastel.decorate("Please specify a method name with --method or -m", Tng::UI::Theme.color(:error))
+       return
+    end
+
+    full_path = File.expand_path(file_path)
+    unless File.exist?(full_path)
+       puts @pastel.decorate("File not found: #{full_path}", Tng::UI::Theme.color(:error))
+       return
+    end
+
+    file_info = { path: full_path, name: File.basename(full_path) }
+    method_info = { name: method_name }
+
+    run_xray_for_method(file_info, method_info)
+  end
+
+  def run_xray_for_method(file_info, method_info)
+    xray_result = nil
+
+    @go_ui.show_spinner("Generating X-Ray for #{method_info[:name]}...") do
+      begin
+        type = Tng::Services::FileTypeDetector.detect_type(file_info[:path])
+        file_object = Tng::Services::FileTypeDetector.build_file_object(file_info[:path], type)
+        generator = Tng::Services::TestGenerator.new(@http_client)
+
+        xray_result = case type
+                      when "controller"
+                        generator.run_xray_for_controller_method(file_object, method_info)
+                      when "model"
+                        generator.run_xray_for_model_method(file_object, method_info)
+                      when "service"
+                        generator.run_xray_for_service_method(file_object, method_info)
+                      else
+                        generator.run_xray_for_other_method(file_object, method_info)
+                      end
+
+        if xray_result&.dig(:error)
+          { success: false, message: xray_result[:message] || "X-Ray failed" }
+        else
+          { success: true, message: "X-Ray generated" }
+        end
+      rescue => e
+        { success: false, message: e.message }
+      end
+    end
+
+    return @go_ui.show_auth_error(xray_result[:message] || "X-Ray failed") if xray_result&.dig(:error)
+
+    if xray_result && xray_result[:mermaid_code]
+      @go_ui.show_xray_results(xray_result, method_info)
+    end
+  end
+
   def select_controller_and_method(action_name)
     controllers = nil
     @go_ui.show_spinner("Analyzing controllers...") do
@@ -1470,18 +1634,129 @@ class CLI
          choice = files.find { |f| f[:name] == selected }
          next unless choice
 
-         methods = extract_other_methods(choice)
-         if methods.empty?
-             @go_ui.show_no_items("methods in #{choice[:name]}")
-             next
-         end
+         # For dead code, we don't need to select a method, just the file.
+         # But this helper yields (file_choice, method_choice).
+         # We might need a simpler selector for dead code if it's file-based only.
+         # Re-using method selector for now if we want per-method, but dead code is usually per-file.
 
-         m_items = methods.map { |m| { name: m[:name], path: choice[:name] } }
-         m_selected = @go_ui.show_list_view("Select Method to #{action_name}", m_items)
-         next if m_selected == "back"
+         # Actually, dead code analysis is whole-file.
+         # So we should probably just return the file choice.
 
-         m_choice = methods.find { |m| m[:name] == m_selected }
-         yield(choice, m_choice)
+         # Let's implement specific helpers for dead code that just pick files.
+      end
+  end
+
+  def handle_dead_code_detection_menu
+    # Pick a file type first to narrow down
+    choice = @go_ui.show_test_type_menu("deadcode")
+    return if choice == "back"
+
+    case choice
+    when "controller"
+      detect_dead_code_for_type("app/controllers", Tng::Analyzers::Controller)
+    when "model"
+      detect_dead_code_for_type("app/models", Tng::Analyzers::Model)
+    when "service"
+      # Service analyzer is a bit different, it scans app/services usually
+      detect_dead_code_for_service
+    when "other"
+      detect_dead_code_for_other
+    end
+  end
+
+  def detect_dead_code_for_type(dir, analyzer_class)
+    files = nil
+    @go_ui.show_spinner("Analyzing files in #{dir}...") do
+      files = analyzer_class.files_in_dir(dir).map do |file|
+        relative_path = file[:path].gsub(%r{^.*#{dir}/}, "").gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+        { name: namespaced_name, path: file[:path] }
+      end
+      { success: true, message: "Found #{files.length} files" }
+    end
+
+    return @go_ui.show_no_items(dir) if files.empty?
+
+    items = files.map { |f| { name: f[:name], path: f[:path] } }
+
+    loop do
+      selected = @go_ui.show_list_view("Select File to Analyze", items)
+      return if selected == "back"
+
+      choice = files.find { |f| f[:name] == selected }
+      next unless choice
+
+      # Run detection on the file
+      run_dead_code_detection_interactive(choice[:path])
+    end
+  end
+
+  def detect_dead_code_for_service
+     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
+
+     return @go_ui.show_no_items("services") if services.empty?
+
+     items = services.map { |s| { name: s[:name], path: s[:path] } }
+
+     loop do
+       selected = @go_ui.show_list_view("Select Service to Analyze", items)
+       return if selected == "back"
+
+       choice = services.find { |s| s[:name] == selected }
+       next unless choice
+
+       run_dead_code_detection_interactive(choice[:path])
+     end
+  end
+
+  def detect_dead_code_for_other
+      files = nil
+      @go_ui.show_spinner("Analyzing other files...") do
+        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 #{files.length} other files" }
+      end
+
+      return @go_ui.show_no_items("other files") if files.empty?
+
+      items = files.map { |f| { name: f[:name], path: f[:path] } }
+
+      loop do
+        selected = @go_ui.show_list_view("Select File to Analyze", items)
+        return if selected == "back"
+
+        choice = files.find { |f| f[:name] == selected }
+        next unless choice
+
+        run_dead_code_detection_interactive(choice[:path])
+      end
+  end
+
+  def run_dead_code_detection_interactive(path)
+      @go_ui.show_spinner("Detecting dead code...") do
+         # Just a visual delay or setup if needed
+         sleep(0.5)
+         { success: true, message: "Analysis complete" }
+      end
+
+      # Reuse the CLI logic but bypass params
+      absolute_path = File.expand_path(path)
+      begin
+        result = Tng.detect_dead_code(absolute_path, true)
+        @go_ui.show_dead_code_results(absolute_path, result)
+      rescue => e
+        @go_ui.display_error("Error detecting dead code: #{e.message}")
       end
   end
 end

data/lib/generators/tng/install_generator.rb

@@ -34,6 +34,7 @@ module Tng
           return unless Rails.env.development?
 
           Tng.configure do |config|
+            # Get your API key from https://app.tng.sh/
             config.api_key = ENV["TNG_API_KEY"]
             config.base_url = ENV["API_BASE_URI"] || "https://app.tng.sh/"
 

data/lib/tng/services/direct_generation.rb

@@ -96,19 +96,41 @@ module Tng
           return
         end
 
-        @go_ui.display_info(@pastel.bright_white("🎯 #{@params[:audit] ? "Auditing" : "Generating test for"} #{file_object[:name]}##{method_info[:name]}..."))
+        action =
+          if @params[:trace]
+            "Tracing"
+          elsif @params[:xray]
+            "Generating X-Ray for"
+          elsif @params[:audit]
+            "Auditing"
+          else
+            "Generating test for"
+          end
+        @go_ui.display_info(@pastel.bright_white("🎯 #{action} #{file_object[:name]}##{method_info[:name]}..."))
 
         result = @go_ui.show_progress("Processing...") do |progress|
           generate_test_result(file_object, method_info, type, progress)
         end
 
         if result&.dig(:error)
-          @go_ui.display_error(@pastel.red("❌ #{@params[:audit] ? "Audit" : "Test generation"} failed: #{result[:message]}"))
+          label =
+            if @params[:trace]
+              "Trace"
+            elsif @params[:xray]
+              "X-Ray"
+            elsif @params[:audit]
+              "Audit"
+            else
+              "Test generation"
+            end
+          @go_ui.display_error(@pastel.red("❌ #{label} failed: #{result[:message]}"))
         elsif result&.dig(:trace_generated)
           if result[:file_path]
             @go_ui.show_trace_results(result[:file_path])
             File.unlink(result[:file_path]) if File.exist?(result[:file_path])
           end
+        elsif @params[:xray]
+          @go_ui.show_xray_results(result, method_info) if result
         elsif @params[:audit]
           display_audit_results(result)
         elsif result && result[:file_path]
@@ -147,6 +169,13 @@ module Tng
 
         if @params[:trace]
           perform_trace_analysis(file_object, method_info, progress)
+        elsif @params[:xray]
+          case type
+          when "controller" then generator.run_xray_for_controller_method(file_object, method_info, progress: progress)
+          when "model" then generator.run_xray_for_model_method(file_object, method_info, progress: progress)
+          when "service" then generator.run_xray_for_service_method(file_object, method_info, progress: progress)
+          else generator.run_xray_for_other_method(file_object, method_info, progress: progress)
+          end
         elsif @params[:audit]
           case type
           when "controller" then generator.run_audit_for_controller_method(file_object, method_info, progress: progress)

data/lib/tng/services/test_generator.rb

@@ -36,6 +36,7 @@ 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)
@@ -53,6 +54,23 @@ module Tng
         run_audit_for_type(other_file, method_info, :other, progress: progress)
       end
 
+      # X-Ray mode - async, polls for completion
+      def run_xray_for_controller_method(controller, method_info, progress: nil)
+        run_xray_for_type(controller, method_info, :controller, progress: progress)
+      end
+
+      def run_xray_for_model_method(model, method_info, progress: nil)
+        run_xray_for_type(model, method_info, :model, progress: progress)
+      end
+
+      def run_xray_for_service_method(service, method_info, progress: nil)
+        run_xray_for_type(service, method_info, :service, progress: progress)
+      end
+
+      def run_xray_for_other_method(other_file, method_info, progress: nil)
+        run_xray_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
@@ -90,13 +108,59 @@ module Tng
         # Pass audit_mode: true as 8th parameter
         case type
         when :controller
-          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, true)
+          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, true, false)
+        when :model
+          Tng.send_request_for_model(name, file_object[:path], method_info, *config, true, false)
+        when :service
+          Tng.send_request_for_service(name, file_object[:path], method_info, *config, true, false)
+        when :other
+          Tng.send_request_for_other(name, file_object[:path], method_info, *config, true, false)
+        end
+      end
+
+      def run_xray_for_type(file_object, method_info, type, progress: nil)
+        response = send_xray_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 audit)
+          result = poll_for_completion(job_id, progress: progress)
+          return { error: :timeout, message: "X-Ray generation timed out" } unless result
+
+          # X-Ray results should contain mermaid_code and explanation
+          result
+        rescue JSON::ParserError => e
+          { error: :parse_error, message: "Failed to parse X-Ray response: #{e.message}" }
+        end
+      end
+
+      def send_xray_request_for_type(file_object, method_info, type)
+        config = request_config
+        name = file_object[:name] || File.basename(file_object[:path], ".rb")
+
+        # Pass xray_mode: true as 9th parameter (audit_mode: false, xray_mode: true)
+        case type
+        when :controller
+          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, false, true)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config, true)
+          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false, true)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config, true)
+          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false, true)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config, true)
+          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false, true)
         end
       end
 
@@ -144,13 +208,13 @@ module Tng
         # 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, false)
+          Tng.send_request_for_controller(name, file_object[:path], method_info, *config, false, false)
         when :model
-          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false)
+          Tng.send_request_for_model(name, file_object[:path], method_info, *config, false, false)
         when :service
-          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false)
+          Tng.send_request_for_service(name, file_object[:path], method_info, *config, false, false)
         when :other
-          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false)
+          Tng.send_request_for_other(name, file_object[:path], method_info, *config, false, false)
         end
       end