tng 0.4.8 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1050b64ce05cdf8195c4bd1a5603161eea0f88c077ccd09e1ad2d3c17d78850f
-  data.tar.gz: 2c38ad45bd123379e2d24cfe4b20e538684c7969ece4dddc7b4d64e546b4c49d
+  metadata.gz: 3ff0f5e157285f7bd53cc4d5d73333bececaa05877d9564862a5d5828531bbe2
+  data.tar.gz: f4f56d75d0ab3beab4fe07c7533dc91ff35a8241ac4137fdade944cc38a56f17
 SHA512:
-  metadata.gz: 5f864c1e9dacc0c05d65304f1c640287c163e2f3d2882df4fa8220e4f656d70586894ddaf9c28fb14e920025802da5ceece8260a4bec42fd0fdfdff67354db90
-  data.tar.gz: e39fe64e2595c3a98fa96647eadc16bd178196fdbd5a831cf8edc20573a8095e687d317faf33daaf7090aeac8899548bf96a07cbb80a4d7ab38fbd2fc02b7707
+  metadata.gz: 0ca98f50fbf918c9ff10d7c0b913283d1ecd2a3bfc9146ec2c0677f2992a8d7101d031b92fa5c5c4d61b13560aaa4da790791aac821771bcff1dd2b321e2d266
+  data.tar.gz: 4f7dc85deec32ca9566b2048de29fe18e18b5270ed0892c7104e4e8395336664370feb05aed5a3a0fee47062f00ff2e6f17837db1b7c0b75f77d548abd501594

data/bin/tng

@@ -52,6 +52,10 @@ class CLI
     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
@@ -95,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"
@@ -152,6 +161,8 @@ class CLI
       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
@@ -190,6 +201,8 @@ class CLI
         normalized << "--audit"
       when /^(?:--)?(trace)$/
         normalized << "--trace"
+      when /^(?:--)?(xray)$/
+        normalized << "--xray"
       when /^(?:--)?(json|j)$/
         normalized << "--json"
       when /^(?:--)?(fix|x)$/
@@ -257,6 +270,8 @@ class CLI
         handle_audit_method
       when "trace"
         handle_trace_method
+      when "xray"
+        handle_xray_method
       when "clones"
         handle_clone_detection
       when "deadcode"
@@ -533,21 +548,16 @@ class CLI
     end
 
     absolute_path = File.expand_path(file_path)
-    json_output = params[:json] || false
 
     begin
       # Always get JSON from Rust for flexibility
       result = Tng.detect_dead_code(absolute_path, true)
 
-      if json_output
-        puts result
+      if @go_ui
+        @go_ui.show_dead_code_results(absolute_path, result)
       else
-        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
+        # Fallback to text output
+        puts Tng.detect_dead_code(absolute_path, false)
       end
     rescue => e
       puts @pastel.red("Error detecting dead code: #{e.message}")
@@ -1217,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
@@ -1244,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
 
@@ -1303,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)
@@ -1327,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
 
@@ -1380,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

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
 

data/lib/tng/ui/go_ui_session.rb

@@ -256,6 +256,37 @@ module Tng
         puts "Trace results error: #{e.message}"
       end
 
+      # Show X-Ray visualization results
+      # @param xray_result [Hash] X-Ray result with mermaid_code
+      # @param method_info [Hash] Optional method info for context
+      def show_xray_results(xray_result, method_info = {})
+        data = {
+          mermaid_code: xray_result[:mermaid_code] || xray_result["mermaid_code"] || "",
+          explanation: xray_result[:explanation] || xray_result["explanation"] || "Logic flow visualization generated by TNG.",
+          method_name: method_info[:name] || method_info["name"] || "",
+          class_name: method_info[:class_name] || method_info["class_name"] || ""
+        }
+
+        # Silently copy to clipboard for mermaid.live
+        mermaid_code = data[:mermaid_code]
+        if RUBY_PLATFORM.include?("darwin")
+          IO.popen("pbcopy", "w") { |io| io.print mermaid_code } rescue nil
+        elsif RUBY_PLATFORM.include?("linux")
+          IO.popen("xclip -selection clipboard", "w") { |io| io.print mermaid_code } rescue nil
+        end
+
+        input_path = _create_temp_file("go_ui_xray", ".json")
+        File.write(input_path, JSON.generate(data))
+
+        begin
+          system(@binary_path, "xray-results", "--file", input_path)
+        rescue StandardError => e
+          puts "X-Ray results error: #{e.message}"
+        ensure
+          _cleanup_temp_file(input_path)
+        end
+      end
+
       # Show clone detection results
       # @param file_path [String] Original file path analyzed
       # @param results [Hash] Clone detection results { matches: [...] }
@@ -376,7 +407,8 @@ module Tng
             { cmd: "bundle exec tng --file=FILE --method=METHOD --audit", desc: "Direct audit mode" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --trace", desc: "Symbolic trace mode" },
             { cmd: "bundle exec tng --file=FILE --clones", desc: "Check for code duplicates" },
-            { cmd: "bundle exec tng --file=FILE --deadcode", desc: "Run dead code detection" }
+            { cmd: "bundle exec tng --file=FILE --deadcode", desc: "Run dead code detection" },
+            { cmd: "bundle exec tng --file=FILE --method=METHOD --xray", desc: "X-Ray visualization" }
           ],
           features: [
             "Controllers, Models, Services",
@@ -386,6 +418,7 @@ module Tng
             "Symbolic execution traces",
             "Duplicate code detection (Clones)",
             "Dead code detection (Rust-powered)",
+            "X-Ray Logic Flow Visualization",
             "Searchable method lists"
           ],
           options: [
@@ -396,12 +429,14 @@ module Tng
             { flag: "--trace", desc: "Run symbolic trace mode" },
             { flag: "--clones", desc: "Run clone detection mode" },
             { flag: "--level=1|2|3|all", desc: "Set clone detection level (default: all)" },
-            { flag: "--deadcode", desc: "Run dead code detection" }
+            { flag: "--deadcode", desc: "Run dead code detection" },
+            { flag: "--xray", desc: "Generate X-Ray visualization" }
           ],
           how_to: [
             "Run 'bundle exec tng' for interactive mode",
             "Run 'tng [file] --clones' for duplicate detection",
             "Run 'tng [file] --deadcode' for dead code analysis",
+            "Run 'tng [file] [method] --xray' for visualization",
             "Select Controller, Model, or Service to start",
             "Choose a method to generate/audit or select 'Check Duplicates'"
           ],

data/lib/tng/ui/json_session.rb

@@ -96,6 +96,20 @@ module Tng
         emit_event("clones", { file_path: file_path, matches: results[:matches] })
       end
 
+      def show_trace_results(trace_file_path)
+        trace_json = JSON.parse(File.read(trace_file_path))
+        emit_event("result", trace_json)
+      end
+
+      def show_dead_code_results(file_path, results_json)
+        parsed = JSON.parse(results_json)
+        emit_event("dead_code", parsed)
+      end
+
+      def show_xray_results(xray_result, method_info = {})
+        emit_event("result", xray_result.merge(method_info: method_info))
+      end
+
       def show_test_results(title, passed, failed, errors, total, results = [])
         emit_event("test_results", {
                      title: title,
@@ -107,6 +121,10 @@ module Tng
                    })
       end
 
+      def show_generation_result(result)
+        emit_event("result", result)
+      end
+
       # ------------------------------------------------------------------
       # Errors & Warnings
       # ------------------------------------------------------------------

data/lib/tng/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tng
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.4.9
 platform: ruby
 authors:
 - ralucab
@@ -222,7 +222,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.4.8 ┘\n"
+  v0.4.9 ┘\n"
 rdoc_options: []
 require_paths:
 - lib