tng 0.5.8 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c21bff06baf68e032466540c8d5bec37f4f666c551864a1c373b24bb2151276
-  data.tar.gz: 33779163fa817ba657a4c7bf65c0bb4acec9b295e5a3e3ba52d89ac6b993b08d
+  metadata.gz: 5ac92dae68f80b3257a5b3b13eb26b58df3bd9e1519991d61604e6cf4710bc4d
+  data.tar.gz: 34cff72d5582236daeff78511aa9614c642e10bedb74024f26249cedbefcd5c6
 SHA512:
-  metadata.gz: 2bcf03611c4a2a3cc9dfd422c44f5808fc1fd7b9dda65acfe14688f5af7d116e8c9502f0467a0717ee5c0aeb407409b6ed085b7dde0018e98de1c9a1a4bac08d
-  data.tar.gz: b6b65a63859d7353b1b809556579c0555041acbdaf2b57f532c4d22625c55ad04cba10a61273046338ff9443474c01f06efe0726622a88be81d0ed923a45bf44
+  metadata.gz: ae6d50a8894289861a03f8f107520f141b0ea394ede15cc69cb33e0367bc895bc6d205cc7381a25b3ec3f5c93ded663fd59f19a8f0f9ee4b0a7779df6313b7a5
+  data.tar.gz: 6632fa1c7f7759f1e45409c6dca7c39dae7852288ae6291a05469427b70578e975a81a97314f81dd56a7840fdced3a9c7c1cd76f5f5dd2b8b8279a86b9c30d36

data/bin/tng

@@ -71,13 +71,6 @@ class CLI
     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", ""
-    example ""
-    example "Regression Check:", ""
-    example "  bundle exec tng --file=app/services/payment_service.rb --method=process --impact", ""
-    example ""
     example "Call Sites:", ""
     example "  bundle exec tng --file=app/services/payment_service.rb --method=process --callsites", ""
     example ""
@@ -131,6 +124,11 @@ class CLI
     desc "Run in audit mode (find issues and behaviours instead of generating tests)"
   end
 
+  flag :prepare do
+    long "--prepare"
+    desc "Prepare audit prompt only (no LLM call)"
+  end
+
   flag :trace do
     long "--trace"
     desc "Generate and visualize a symbolic trace"
@@ -141,16 +139,6 @@ class CLI
     desc "Find in-repo call sites for a method"
   end
 
-  flag :impact do
-    long "--impact"
-    desc "Run regression check (compare against Git HEAD)"
-  end
-
-  flag :xray do
-    long "--xray"
-    desc "Generate X-Ray visualization (Mermaid flowchart)"
-  end
-
   flag :json do
     short "-j"
     long "--json"
@@ -213,16 +201,12 @@ class CLI
 
     if params[:fix]
       handle_fix_command
-    elsif params[:impact] && params[:file]
-      run_direct_impact
     elsif params[:callsites] && params[:file]
       run_direct_call_sites
     elsif params[:trace] && params[:file]
       run_direct_trace
     elsif params[:deadcode]
       run_dead_code_detection
-    elsif params[:xray] && params[:file]
-      run_direct_xray
     elsif params[:file]
       run_direct_generation
     else
@@ -259,12 +243,10 @@ class CLI
         normalized << "--method=#{::Regexp.last_match(2)}"
       when /^(?:--)?(audit|a)$/
         normalized << "--audit"
+      when /^(?:--)?(prepare)$/
+        normalized << "--prepare"
       when /^(?:--)?(trace)$/
         normalized << "--trace"
-      when /^(?:--)?(impact)$/
-        normalized << "--impact"
-      when /^(?:--)?(xray)$/
-        normalized << "--xray"
       when /^(?:--)?(callsites)$/
         normalized << "--callsites"
       when /^(?:--)?(json|j)$/
@@ -336,10 +318,6 @@ class CLI
         handle_audit_method
       when "trace"
         handle_trace_method
-      when "impact"
-        handle_impact_method
-      when "xray"
-        handle_xray_method
       when "clones"
         handle_clone_detection
       when "deadcode"
@@ -1589,46 +1567,6 @@ class CLI
     end
   end
 
-  def handle_impact_method
-    if @generic_mode
-      handle_generic_impact
-      return
-    end
-
-    choice = @go_ui.show_test_type_menu("impact")
-
-    case choice
-    when "controller"
-      impact_controller_method
-    when "model"
-      impact_model_method
-    when "service"
-      impact_service_method
-    when "other"
-      impact_other_method
-    end
-  end
-
-  def handle_xray_method
-    if @generic_mode
-      handle_generic_xray
-      return
-    end
-
-    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)
@@ -1653,54 +1591,6 @@ class CLI
     end
   end
 
-  def impact_controller_method
-    select_controller_and_method("Regression Check") do |controller, method_info|
-      run_impact_for_method(controller, method_info)
-    end
-  end
-
-  def impact_model_method
-    select_model_and_method("Regression Check") do |model, method_info|
-      run_impact_for_method(model, method_info)
-    end
-  end
-
-  def impact_service_method
-    select_service_and_method("Regression Check") do |service, method_info|
-      run_impact_for_method(service, method_info)
-    end
-  end
-
-  def impact_other_method
-    select_other_and_method("Regression Check") do |file, method_info|
-      run_impact_for_method(file, method_info)
-    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
 
@@ -1766,54 +1656,6 @@ class CLI
     end
   end
 
-  def run_impact_for_method(file_info, method_info)
-    result_path = nil
-
-    @go_ui.show_spinner("Running regression check for #{method_info[:name]}...") do
-      begin
-        project_root = Dir.pwd
-        path = File.expand_path(file_info[:path])
-
-        class_name =
-          if @generic_mode
-            method_info[:class_name]
-          else
-            method_info[:class_name] || file_info[:name]
-          end
-        impact_json =
-          if @generic_mode
-            Tng::Analyzer::Context.analyze_impact_ruby(
-              project_root,
-              path,
-              method_info[:name],
-              class_name
-            )
-          else
-            Tng::Analyzer::Context.analyze_impact(
-              project_root,
-              path,
-              method_info[:name],
-              class_name
-            )
-          end
-
-        f = Tempfile.new(['impact', '.json'])
-        f.write(JSON.generate(impact_json))
-        f.close
-        result_path = f.path
-
-        { success: true, message: "Regression check completed" }
-      rescue => e
-        { success: false, message: e.message }
-      end
-    end
-
-    if result_path
-      @go_ui.show_impact_results(result_path)
-      File.unlink(result_path) if File.exist?(result_path)
-    end
-  end
-
   def run_direct_trace
     file_path = params[:file]
     method_name = params[:method]
@@ -1891,103 +1733,6 @@ class CLI
     puts @pastel.dim("... #{sites.length - 200} more") if sites.length > 200
   end
 
-  def run_direct_impact
-    file_path = params[:file]
-    method_name = params[:method]
-    class_name = params[:class_name]
-
-    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
-    return unless ensure_not_ignored(full_path)
-
-    relative_path = full_path.gsub("#{Dir.pwd}/", "")
-    namespaced_name = relative_path.sub(/\.rb\z/, "").split("/").map(&:camelize).join("::")
-    file_info = { path: full_path, name: namespaced_name }
-    method_info = { name: method_name, class_name: class_name }
-
-    run_impact_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
-    return unless ensure_not_ignored(full_path)
-
-    relative_path = full_path.gsub("#{Dir.pwd}/", "")
-    namespaced_name = relative_path.sub(/\.rb\z/, "").split("/").map(&:camelize).join("::")
-    file_info = { path: full_path, name: namespaced_name }
-    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
-        generator = Tng::Services::TestGenerator.new(@http_client)
-
-        if @generic_mode
-          method_info = method_info.merge(test_type: method_info[:test_type] || "other")
-          file_object = generic_file_object(file_info)
-          xray_result = generator.run_xray_for_ruby_method(file_object, method_info)
-        else
-          type = Tng::Services::FileTypeDetector.detect_type(file_info[:path])
-          file_object = Tng::Services::FileTypeDetector.build_file_object(file_info[:path], type)
-
-          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
-        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
@@ -2268,32 +2013,6 @@ class CLI
     display_audit_results(audit_result || result)
   end
 
-  def handle_generic_xray
-    selection = select_generic_method_and_type("X-Ray")
-    return if selection.nil?
-
-    file_info, method_info = selection
-    file_object = generic_file_object(file_info)
-
-    xray_result = nil
-    @go_ui.show_spinner("Generating X-Ray for #{method_info[:name]}...") do
-      xray_result = Tng::Services::TestGenerator.new(@http_client).run_xray_for_ruby_method(
-        file_object,
-        method_info
-      )
-
-      if xray_result&.dig(:error)
-        { success: false, message: xray_result[:message] || "X-Ray failed" }
-      else
-        { success: true, message: "X-Ray generated" }
-      end
-    end
-
-    return @go_ui.display_error(@pastel.red("❌ X-Ray failed: #{xray_result[:message]}")) if xray_result&.dig(:error)
-
-    @go_ui.show_xray_results(xray_result, method_info) if xray_result
-  end
-
   def handle_generic_trace
     file_info = select_generic_file("Trace")
     return if file_info.nil?
@@ -2304,16 +2023,6 @@ class CLI
     run_trace_for_method(file_info, method_info)
   end
 
-  def handle_generic_impact
-    file_info = select_generic_file("Regression Check")
-    return if file_info.nil?
-
-    method_info = select_generic_method(file_info, "Regression Check")
-    return if method_info.nil?
-
-    run_impact_for_method(file_info, method_info)
-  end
-
   def handle_generic_clone_detection
     file_info = select_generic_file("Check Duplicates")
     return if file_info.nil?

data/lib/tng/services/direct_generation.rb

@@ -135,8 +135,6 @@ module Tng
         action =
           if @params[:trace]
             "Tracing"
-          elsif @params[:xray]
-            "Generating X-Ray for"
           elsif @params[:audit]
             "Auditing"
           else
@@ -153,8 +151,6 @@ module Tng
           label =
             if @params[:trace]
               "Trace"
-            elsif @params[:xray]
-              "X-Ray"
             elsif @params[:audit]
               "Audit"
             else
@@ -166,8 +162,6 @@ module Tng
             @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]
@@ -206,24 +200,15 @@ module Tng
 
         if !Tng::Utils.rails_project?(Dir.pwd)
           method_info = method_info.merge(test_type: method_info[:test_type] || "other")
-          return generator.run_for_ruby_method(file_object, method_info, progress: progress) unless @params[:trace] || @params[:audit] || @params[:xray]
+          return generator.run_for_ruby_method(file_object, method_info, progress: progress) unless @params[:trace] || @params[:audit]
 
           if @params[:audit]
             return generator.run_audit_for_ruby_method(file_object, method_info, progress: progress)
-          elsif @params[:xray]
-            return generator.run_xray_for_ruby_method(file_object, method_info, progress: progress)
           end
         end
 
         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

@@ -62,28 +62,6 @@ module Tng
       def run_audit_for_ruby_method(other_file, method_info, progress: nil)
         run_audit_for_ruby(other_file, method_info, 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_xray_for_ruby_method(other_file, method_info, progress: nil)
-        run_xray_for_ruby(other_file, method_info, 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
@@ -131,54 +109,6 @@ module Tng
           Tng.send_request_for_other(name, file_object[:path], enriched_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, content_path: CONTENT_RESPONSES_PATH)
-          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")
-        enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: false)
-
-        # 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], enriched_method_info, *config, false, true)
-        when :model
-          Tng.send_request_for_model(name, file_object[:path], enriched_method_info, *config, false, true)
-        when :service
-          Tng.send_request_for_service(name, file_object[:path], enriched_method_info, *config, false, true)
-        when :other
-          Tng.send_request_for_other(name, file_object[:path], enriched_method_info, *config, false, true)
-        end
-      end
-
       def generate_test_for_type(file_object, method_info, type, progress: nil)
         start_time = Time.now
 
@@ -237,7 +167,7 @@ module Tng
       def generate_test_for_ruby(file_object, method_info, progress: nil)
         start_time = Time.now
 
-        response = send_request_for_ruby(file_object, method_info, audit_mode: false, xray_mode: false)
+        response = send_request_for_ruby(file_object, method_info, audit_mode: false)
         return unless response
 
         if response.is_a?(HTTPX::ErrorResponse)
@@ -266,7 +196,7 @@ module Tng
       end
 
       def run_audit_for_ruby(file_object, method_info, progress: nil)
-        response = send_request_for_ruby(file_object, method_info, audit_mode: true, xray_mode: false)
+        response = send_request_for_ruby(file_object, method_info, audit_mode: true)
         return { error: :network_error, message: "Network error" } unless response
 
         if response.is_a?(HTTPX::ErrorResponse)
@@ -291,40 +221,12 @@ module Tng
           { error: :parse_error, message: "Failed to parse audit response: #{e.message}" }
         end
       end
-
-      def run_xray_for_ruby(file_object, method_info, progress: nil)
-        response = send_request_for_ruby(file_object, method_info, audit_mode: false, xray_mode: true)
-        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
-
-          result = poll_for_completion(job_id, progress: progress, content_path: RUBY_CONTENT_RESPONSES_PATH)
-          return { error: :timeout, message: "X-Ray generation timed out" } unless result
-
-          result
-        rescue JSON::ParserError => e
-          { error: :parse_error, message: "Failed to parse X-Ray response: #{e.message}" }
-        end
-      end
-
-      def send_request_for_ruby(file_object, method_info, audit_mode:, xray_mode:)
+      def send_request_for_ruby(file_object, method_info, audit_mode:)
         config = request_config
         name = file_object[:name] || File.basename(file_object[:path], ".rb")
         enriched_method_info = enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode: true)
 
-        Tng.send_request_for_ruby(name, file_object[:path], enriched_method_info, *config, audit_mode, xray_mode)
+        Tng.send_request_for_ruby(name, file_object[:path], enriched_method_info, *config, audit_mode, false)
       end
 
       def enrich_method_info_with_trace_v2(file_object, method_info, ruby_mode:)

data/lib/tng/ui/go_ui_session.rb

@@ -275,45 +275,6 @@ module Tng
         puts "Trace results error: #{e.message}"
       end
 
-      # Show regression check results
-      # @param impact_file_path [String] Path to JSON impact file
-      def show_impact_results(impact_file_path)
-        system(@binary_path, "ruby-impact-results", "--file", impact_file_path)
-      rescue StandardError => e
-        puts "Impact 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: [...] }
@@ -434,10 +395,9 @@ module Tng
             { cmd: "bundle exec tng --file=FILE --method=METHOD", desc: "Direct test generation" },
             { 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 --method=METHOD --impact", desc: "Regression check 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 --method=METHOD --xray", desc: "X-Ray visualization" }
+            
           ],
           features: [
             "Controllers, Models, Services",
@@ -445,10 +405,8 @@ module Tng
             "Per-method test generation",
             "Code audit for issues & behaviors",
             "Symbolic execution traces",
-            "Regression check against Git HEAD",
             "Duplicate code detection (Clones)",
             "Dead code detection (Rust-powered)",
-            "X-Ray Logic Flow Visualization",
             "Searchable method lists"
           ],
           options: [
@@ -457,17 +415,16 @@ module Tng
             { flag: "--method=NAME", desc: "Method name to generate test for" },
             { flag: "--audit", desc: "Run audit mode instead of test generation" },
             { flag: "--trace", desc: "Run symbolic trace mode" },
-            { flag: "--impact", desc: "Run regression check 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: "--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

@@ -101,11 +101,6 @@ module Tng
         emit_event("result", trace_json)
       end
 
-      def show_impact_results(impact_file_path)
-        impact_json = JSON.parse(File.read(impact_file_path))
-        emit_event("result", impact_json)
-      end
-
       def show_dead_code_results(file_path, results_json)
         parsed = JSON.parse(results_json)
         emit_event("dead_code", parsed)
@@ -130,6 +125,10 @@ module Tng
         emit_event("result", result)
       end
 
+      def show_prompt(content)
+        emit_event("prompt", { content: content.to_s })
+      end
+
       # ------------------------------------------------------------------
       # Errors & Warnings
       # ------------------------------------------------------------------

data/lib/tng/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tng
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.9
 platform: ruby
 authors:
 - ralucab
@@ -201,7 +201,7 @@ metadata:
   source_code_uri: https://github.com/tng-sh/tng-rails-public
   license_uri: https://github.com/tng-sh/tng-rails-public/blob/main/LICENSE.md
 post_install_message: |-
-  TNG v0.5.8 installed successfully!
+  TNG v0.5.9 installed successfully!
   Run 'bundle exec tng init' to get started.
   Use 'bundle exec tng --help' for usage information.
 rdoc_options: []