rails-ai-context 4.3.2 → 4.4.0

data/lib/rails_ai_context/introspectors/engine_introspector.rb

@@ -99,11 +99,20 @@ module RailsAiContext
           next if engine.name == "RailsAiContext::Engine"
           next if engine.name.start_with?("Rails::", "ActionPack::", "ActionView::", "ActiveModel::")
 
-          { name: engine.name, root: engine.root.to_s.sub("#{Gem.dir}/gems/", "") }
-        rescue
+          entry = { name: engine.name, root: engine.root.to_s.sub("#{Gem.dir}/gems/", "") }
+          # Count routes and models inside the engine
+          if engine.respond_to?(:routes) && engine.routes.respond_to?(:routes)
+            entry[:route_count] = engine.routes.routes.size rescue nil
+          end
+          models_dir = File.join(engine.root.to_s, "app", "models")
+          entry[:model_count] = Dir.glob(File.join(models_dir, "**/*.rb")).size if Dir.exist?(models_dir)
+          entry.compact
+        rescue => e
+          $stderr.puts "[rails-ai-context] discover_rails_engines failed: #{e.message}" if ENV["DEBUG"]
           nil
         end.sort_by { |e| e[:name] }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] discover_rails_engines failed: #{e.message}" if ENV["DEBUG"]
         []
       end
     end

data/lib/rails_ai_context/introspectors/frontend_framework_introspector.rb

@@ -106,6 +106,8 @@ module RailsAiContext
           typescript: ts,
           monorepo: mono,
           build_tool: build,
+          api_clients: detect_api_clients(all_deps),
+          component_libraries: detect_component_libraries(all_deps),
           summary: build_summary(frameworks, mounting, build, ts, total_components)
         }
       rescue => e
@@ -413,12 +415,45 @@ module RailsAiContext
         false
       end
 
+      API_CLIENT_MARKERS = {
+        "axios" => "Axios", "ky" => "Ky", "got" => "Got",
+        "@tanstack/react-query" => "TanStack Query", "swr" => "SWR",
+        "apollo-client" => "Apollo Client", "@apollo/client" => "Apollo Client",
+        "urql" => "URQL", "graphql-request" => "graphql-request",
+        "relay-runtime" => "Relay"
+      }.freeze
+
+      COMPONENT_LIB_MARKERS = {
+        "@mui/material" => "MUI", "@chakra-ui/react" => "Chakra UI",
+        "@radix-ui/react-dialog" => "Radix UI", "@headlessui/react" => "Headless UI",
+        "antd" => "Ant Design", "@mantine/core" => "Mantine",
+        "shadcn-ui" => "shadcn/ui", "@shadcn/ui" => "shadcn/ui",
+        "daisyui" => "DaisyUI", "flowbite" => "Flowbite",
+        "primereact" => "PrimeReact", "vuetify" => "Vuetify",
+        "element-plus" => "Element Plus", "naive-ui" => "Naive UI"
+      }.freeze
+
+      def detect_api_clients(all_deps)
+        API_CLIENT_MARKERS.filter_map { |pkg, label| label if all_deps.key?(pkg) }.uniq
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_api_clients failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
+      def detect_component_libraries(all_deps)
+        COMPONENT_LIB_MARKERS.filter_map { |pkg, label| label if all_deps.key?(pkg) }.uniq
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_component_libraries failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
       def package_json_has_script?(name)
         path = File.join(root, "package.json")
         return false unless File.exist?(path)
         content = File.read(path, encoding: "bom|utf-8")
         content.include?("\"#{name}\"")
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] package_json_has_script? failed: #{e.message}" if ENV["DEBUG"]
         false
       end
     end

data/lib/rails_ai_context/introspectors/gem_introspector.rb

@@ -161,12 +161,58 @@ module RailsAiContext
           total_gems: specs.size,
           ruby_version: specs["ruby"]&.first,
           notable_gems: detect_notable_gems(specs),
-          categories: categorize_gems(specs)
+          categories: categorize_gems(specs),
+          local_gems: detect_local_gems,
+          gem_groups: detect_gem_groups
         }
       end
 
       private
 
+      def detect_local_gems
+        gemfile = File.join(app.root, "Gemfile")
+        return [] unless File.exist?(gemfile)
+
+        content = File.read(gemfile)
+        local = []
+        content.each_line do |line|
+          next if line.strip.start_with?("#")
+          if (match = line.match(/gem\s+["'](\w[\w-]*)["'].*path:\s*["']([^"']+)["']/))
+            local << { name: match[1], source: "path", location: match[2] }
+          elsif (match = line.match(/gem\s+["'](\w[\w-]*)["'].*git:\s*["']([^"']+)["']/))
+            local << { name: match[1], source: "git", location: match[2] }
+          end
+        end
+        local
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_local_gems failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
+      def detect_gem_groups
+        gemfile = File.join(app.root, "Gemfile")
+        return {} unless File.exist?(gemfile)
+
+        content = File.read(gemfile)
+        groups = {}
+        current_group = nil
+        content.each_line do |line|
+          stripped = line.strip
+          next if stripped.start_with?("#")
+          if (match = stripped.match(/\Agroup\s+(.+?)\s+do\b/))
+            current_group = match[1].scan(/:(\w+)/).flatten
+          elsif stripped == "end" && current_group
+            current_group = nil
+          elsif current_group && (match = stripped.match(/\Agem\s+["'](\w[\w-]*)["']/))
+            current_group.each { |g| (groups[g] ||= []) << match[1] }
+          end
+        end
+        groups
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_gem_groups failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
       def parse_lockfile(path)
         gems = {}
         in_gems = false

data/lib/rails_ai_context/introspectors/i18n_introspector.rb

@@ -13,13 +13,16 @@ module RailsAiContext
       end
 
       def call
-        {
+        result = {
           default_locale: I18n.default_locale.to_s,
           available_locales: I18n.available_locales.map(&:to_s).sort,
           backend: I18n.backend.class.name,
           locale_files: extract_locale_files,
-          total_locale_files: count_locale_files
+          total_locale_files: count_locale_files,
+          locale_coverage: detect_locale_coverage
         }
+        result.merge!(detect_fallback_config)
+        result
       rescue => e
         { error: e.message }
       end
@@ -42,7 +45,8 @@ module RailsAiContext
             begin
               data = YAML.load_file(path, permitted_classes: [ Symbol ], aliases: true) || {}
               info[:key_count] = count_keys(data)
-            rescue
+            rescue => e
+              $stderr.puts "[rails-ai-context] extract_locale_files failed: #{e.message}" if ENV["DEBUG"]
               info[:parse_error] = true
             end
           end
@@ -61,6 +65,48 @@ module RailsAiContext
         return 0 unless hash.is_a?(Hash)
         hash.sum { |_, v| v.is_a?(Hash) ? count_keys(v, depth: depth + 1) : 1 }
       end
+
+      def detect_fallback_config
+        config = {}
+        config[:fallbacks] = I18n.fallbacks.to_h.transform_values { |v| v.map(&:to_s) } if I18n.respond_to?(:fallbacks) && I18n.fallbacks
+        config
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_fallback_config failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
+      def detect_locale_coverage
+        locales = I18n.available_locales
+        return {} if locales.size < 2
+
+        # Compare key counts between default and other locales
+        coverage = {}
+        default_count = count_keys_for_locale(I18n.default_locale)
+        locales.reject { |l| l == I18n.default_locale }.each do |locale|
+          locale_count = count_keys_for_locale(locale)
+          coverage[locale.to_s] = { keys: locale_count, coverage_pct: default_count > 0 ? ((locale_count.to_f / default_count) * 100).round(1) : 0 }
+        end
+        coverage
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_locale_coverage failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
+      def count_keys_for_locale(locale)
+        path = Dir.glob(File.join(app.root, "config", "locales", "#{locale}.yml")).first
+        return 0 unless path && File.exist?(path)
+        data = YAML.safe_load(File.read(path), permitted_classes: [ Symbol ])
+        count_nested_keys(data)
+      rescue => e
+        $stderr.puts "[rails-ai-context] count_keys_for_locale failed: #{e.message}" if ENV["DEBUG"]
+        0
+      end
+
+      def count_nested_keys(hash, count = 0)
+        return count unless hash.is_a?(Hash)
+        hash.each_value { |v| count = v.is_a?(Hash) ? count_nested_keys(v, count) : count + 1 }
+        count
+      end
     end
   end
 end

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -20,7 +20,9 @@ module RailsAiContext
         {
           jobs: jobs,
           mailers: extract_mailers,
-          channels: extract_channels
+          channels: extract_channels,
+          recurring_jobs: extract_solid_queue_recurring,
+          sidekiq_config: extract_sidekiq_config
         }
       end
 
@@ -42,7 +44,8 @@ module RailsAiContext
             priority: job.priority
           }.compact
         end.sort_by { |j| j[:name] }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_jobs failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -73,17 +76,55 @@ module RailsAiContext
           perform_match = source.match(/def\s+perform\s*\(([^)]*)\)/)
           perform_signature = perform_match ? perform_match[1].strip : nil
 
+          callbacks = source.scan(/\b(before_enqueue|after_enqueue|before_perform|after_perform|around_perform|around_enqueue)\b/).flatten.uniq
+
           job = { name: name }
           job[:queue] = queue if queue
           job[:retry_on] = retry_on if retry_on.any?
           job[:discard_on] = discard_on if discard_on.any?
           job[:perform_signature] = perform_signature if perform_signature
+          job[:callbacks] = callbacks if callbacks.any?
           job
         end.sort_by { |j| j[:name] }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_jobs_from_source failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
+      def extract_solid_queue_recurring
+        paths = [
+          File.join(app.root, "config", "recurring.yml"),
+          File.join(app.root, "config", "solid_queue.yml")
+        ]
+        path = paths.find { |p| File.exist?(p) }
+        return [] unless path
+
+        content = File.read(path)
+        jobs = []
+        content.scan(/(\w+):\s*\n\s+class:\s*(\w+).*?(?:schedule:\s*["']?([^"'\n]+))?/m) do |name, klass, schedule|
+          jobs << { name: name, class: klass, schedule: schedule&.strip }.compact
+        end
+        jobs
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_solid_queue_recurring failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
+      def extract_sidekiq_config
+        path = File.join(app.root, "config", "sidekiq.yml")
+        return nil unless File.exist?(path)
+
+        content = File.read(path)
+        config = {}
+        config[:concurrency] = $1.to_i if content.match(/concurrency:\s*(\d+)/)
+        queues = content.scan(/-\s*(?:\[?\s*)?(\w+)/).flatten.uniq
+        config[:queues] = queues if queues.any?
+        config.empty? ? nil : config
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_sidekiq_config failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
       def extract_mailers
         return [] unless defined?(ActionMailer::Base)
 
@@ -99,7 +140,8 @@ module RailsAiContext
             delivery_method: mailer.delivery_method.to_s
           }
         end.sort_by { |m| m[:name] }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_mailers failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -116,7 +158,8 @@ module RailsAiContext
               .map(&:to_s)
           }
         end.sort_by { |c| c[:name] }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_channels failed: #{e.message}" if ENV["DEBUG"]
         []
       end
     end

data/lib/rails_ai_context/introspectors/middleware_introspector.rb

@@ -17,7 +17,8 @@ module RailsAiContext
         {
           custom_middleware: custom,
           middleware_stack: extract_middleware_stack,
-          middleware_count: middleware_count(custom)
+          middleware_count: middleware_count(custom),
+          middleware_from_initializers: detect_middleware_from_initializers
         }
       rescue => e
         { error: e.message }
@@ -65,7 +66,8 @@ module RailsAiContext
           name = middleware.name || middleware.klass.to_s
           { name: name, category: categorize_middleware(name) }
         end
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_middleware_stack failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -74,10 +76,29 @@ module RailsAiContext
           total: app.middleware.size,
           custom: custom.size
         }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] middleware_count failed: #{e.message}" if ENV["DEBUG"]
         {}
       end
 
+      def detect_middleware_from_initializers
+        init_dir = File.join(root, "config/initializers")
+        return [] unless Dir.exist?(init_dir)
+
+        additions = []
+        Dir.glob(File.join(init_dir, "*.rb")).each do |path|
+          content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          content.scan(/config\.middleware\.(?:use|insert_before|insert_after|insert|unshift)\s+(\S+)/).each do |match|
+            name = match[0].gsub(/,.*/, "").strip
+            additions << { middleware: name, file: File.basename(path) } unless name.empty?
+          end
+        end
+        additions.uniq
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_middleware_from_initializers failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+
       def categorize_middleware(name)
         case name
         when /ActionDispatch::SSL|ForceSSL/ then "security"

data/lib/rails_ai_context/introspectors/migration_introspector.rb

@@ -93,7 +93,8 @@ module RailsAiContext
         content = File.read(schema_path)
         match = content.match(/version:\s*([\d_]+)/)
         match ? match[1].delete("_") : nil
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] current_schema_version failed: #{e.message}" if ENV["DEBUG"]
         nil
       end
 
@@ -117,9 +118,11 @@ module RailsAiContext
         %w[
           create_table drop_table rename_table
           add_column remove_column rename_column change_column
+          change_column_default change_column_null
           add_index remove_index add_reference remove_reference
           add_foreign_key remove_foreign_key
           add_timestamps create_join_table enable_extension execute
+          add_check_constraint remove_check_constraint
         ].select { |action| content.include?(action) }
       end
     end

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -39,7 +39,8 @@ module RailsAiContext
         else
           Rails.application.eager_load!
         end
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] eager_load_models! failed: #{e.message}" if ENV["DEBUG"]
         # In some environments (CI, Claude Code) eager_load may partially fail
         nil
       end
@@ -90,6 +91,14 @@ module RailsAiContext
           instance_methods: extract_public_instance_methods(model)
         }
 
+        # STI hierarchy detection
+        sti_info = extract_sti_info(model)
+        details[:sti] = sti_info if sti_info
+
+        # Enum prefix/suffix options
+        enum_options = extract_enum_options(model)
+        details[:enum_options] = enum_options if enum_options.any?
+
         # Source-based macro extractions
         macros = extract_source_macros(model)
         details.merge!(macros)
@@ -101,6 +110,45 @@ module RailsAiContext
         details.compact
       end
 
+      def extract_sti_info(model)
+        has_type_column = if model.connected? && model.table_exists?
+          model.columns_hash.key?("type")
+        else
+          # Fallback: check schema.rb for type column
+          schema_path = File.join(app.root.to_s, "db", "schema.rb")
+          if File.exist?(schema_path)
+            schema = File.read(schema_path)
+            table_section = schema[/create_table\s+"#{Regexp.escape(model.table_name)}".*?end/m]
+            table_section&.match?(/t\.\w+\s+"type"/)
+          end
+        end
+
+        return nil unless has_type_column
+
+        children = if model.respond_to?(:descendants)
+          model.descendants.map(&:name).compact.sort
+        elsif model.respond_to?(:subclasses)
+          model.subclasses.map(&:name).compact.sort
+        else
+          []
+        end
+
+        parent = model.superclass
+        sti_parent = if parent && parent != ActiveRecord::Base &&
+                        (!defined?(ApplicationRecord) || parent != ApplicationRecord)
+          parent.name
+        end
+
+        {
+          sti_base: sti_parent.nil? && children.any?,
+          sti_parent: sti_parent,
+          sti_children: children.empty? ? nil : children
+        }.compact
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_sti_info failed: #{e.message}" if ENV["DEBUG"]
+        nil
+      end
+
       def extract_associations(model)
         model.reflect_on_all_associations.map do |assoc|
           detail = {
@@ -135,7 +183,8 @@ module RailsAiContext
         source.scan(/^\s*scope\s+:(\w+)\s*,\s*->\s*(?:\([^)]*\)\s*)?\{([^}]*)\}/m).map do |name, body|
           { name: name, body: body.strip }
         end
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_scopes failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -146,7 +195,8 @@ module RailsAiContext
         return [] unless source_path && File.exist?(source_path)
 
         File.read(source_path).scan(/^\s*validate\s+:(\w+)/).flatten
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_custom_validates failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -162,6 +212,35 @@ module RailsAiContext
         model.defined_enums.transform_values { |mapping| mapping.dup }
       end
 
+      def extract_enum_options(model)
+        source_path = model_source_path(model)
+        return {} unless source_path && File.exist?(source_path)
+
+        source = File.read(source_path)
+        options = {}
+        source.each_line do |line|
+          next unless line.match?(/\A\s*enum\s+/)
+          # Match both `enum :name, { ... }` and `enum name: { ... }` forms
+          name_match = line.match(/enum\s+:(\w+)/) || line.match(/enum\s+(\w+):/)
+          next unless name_match
+          enum_name = name_match[1]
+          entry = {}
+          entry[:prefix] = true if line.match?(/_?prefix:\s*true/)
+          entry[:suffix] = true if line.match?(/_?suffix:\s*true/)
+          if (prefix_val = line.match(/_?prefix:\s*:(\w+)/))
+            entry[:prefix] = prefix_val[1]
+          end
+          if (suffix_val = line.match(/_?suffix:\s*:(\w+)/))
+            entry[:suffix] = suffix_val[1]
+          end
+          options[enum_name] = entry if entry.any?
+        end
+        options
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_enum_options failed: #{e.message}" if ENV["DEBUG"]
+        {}
+      end
+
       def extract_callbacks(model)
         callback_types = %i[
           before_validation after_validation
@@ -174,7 +253,7 @@ module RailsAiContext
 
         result = callback_types.each_with_object({}) do |type, hash|
           callbacks = model.send(:"_#{type}_callbacks").reject do |cb|
-            cb.filter.to_s.start_with?(*EXCLUDED_CALLBACKS) || cb.filter.is_a?(Proc)
+            cb.filter.nil? || cb.filter.to_s.start_with?(*EXCLUDED_CALLBACKS) || cb.filter.is_a?(Proc)
           end
 
           next if callbacks.empty?
@@ -185,7 +264,8 @@ module RailsAiContext
         # If reflection returned nothing, fall back to source parsing
         return result if result.any?
         extract_callbacks_from_source(model)
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_callbacks failed: #{e.message}" if ENV["DEBUG"]
         extract_callbacks_from_source(model)
       end
 
@@ -200,11 +280,17 @@ module RailsAiContext
           if (match = line.match(/\A\s*(before_validation|after_validation|before_save|after_save|before_create|after_create|before_update|after_update|before_destroy|after_destroy|after_commit|after_rollback)\s+:(\w+)/))
             type = match[1]
             method_name = match[2]
+            on_match = line.match(/on:\s*(?::(\w+)|\[([^\]]+)\])/)
+            if on_match && type.start_with?("after_commit")
+              events = on_match[1] ? [ on_match[1] ] : on_match[2].scan(/:(\w+)/).flatten
+              type = events.map { |e| "after_commit_on_#{e}" }.join(", ")
+            end
             (callbacks[type] ||= []) << method_name
           end
         end
         callbacks
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_callbacks_from_source failed: #{e.message}" if ENV["DEBUG"]
         {}
       end
 
@@ -276,7 +362,8 @@ module RailsAiContext
           in_class_methods = false if in_class_methods && line.match?(/\A\s*end\s*$/) && !line.match?(/def/)
         end
         methods.uniq
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_source_class_methods failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -326,13 +413,16 @@ module RailsAiContext
         source.each_line do |line|
           in_private = true if line.match?(/\A\s*private\s*$/)
           next if in_private
+          # Also detect inline private/protected modifiers
+          next if line.match?(/\A\s*(?:private|protected)\s+def\s/)
           next if line.match?(/\A\s*def self\./)
           if (match = line.match(/\A\s*def (\w+[?!]?)/))
             methods << match[1] unless match[1] == "initialize"
           end
         end
         methods.uniq
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_source_instance_methods failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -350,7 +440,8 @@ module RailsAiContext
           ])
         end
         methods
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] generated_association_methods failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
@@ -372,6 +463,10 @@ module RailsAiContext
         macros[:serialize] = source.scan(/\bserialize\s+:(\w+)/).flatten if source.match?(/\bserialize\s+:/)
         macros[:store] = source.scan(/\bstore(?:_accessor)?\s+:(\w+)/).flatten if source.match?(/\bstore(?:_accessor)?\s+:/)
 
+        # attribute API declarations (e.g. attribute :field, :type)
+        attributes = source.scan(/\battribute\s+:(\w+),\s*:(\w+)/).map { |name, type| { name: name, type: type } }
+        macros[:attributes] = attributes if attributes.any?
+
         # Constants with value lists (e.g. STATUSES = %w[pending completed])
         constants = source.scan(/\b([A-Z][A-Z_]+)\s*=\s*%[wi]\[([^\]]+)\]/).map do |name, values|
           { name: name, values: values.split }
@@ -390,7 +485,8 @@ module RailsAiContext
 
         # Remove empty arrays
         macros.reject { |_, v| v.is_a?(Array) && v.empty? }
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_source_macros failed: #{e.message}" if ENV["DEBUG"]
         {}
       end
 
@@ -443,7 +539,8 @@ module RailsAiContext
         macros[:token_generation] = tokens if tokens.any?
 
         macros
-      rescue
+      rescue => e
+        $stderr.puts "[rails-ai-context] extract_detailed_macros failed: #{e.message}" if ENV["DEBUG"]
         {}
       end