rails-ai-context 4.2.3 → 4.3.1

data/lib/rails_ai_context/tools/get_context.rb

@@ -94,10 +94,18 @@ module RailsAiContext
           lines << view_text
         end
 
-        # Cross-reference: controller ivars vs the specific action's view ivars (not all views)
-        ctrl_ivars = extract_ivars_from_text(ctrl_result.content.first[:text])
+        # Cross-reference: controller ivars vs view ivars
+        # Also check templates rendered by the action (e.g., create renders :new on failure)
+        ctrl_text = ctrl_result.content.first[:text]
+        ctrl_ivars = extract_ivars_from_text(ctrl_text)
         view_ivars = extract_ivars_from_view_text(view_text, action: action_name)
-        ivar_check = cross_reference_ivars(ctrl_ivars, view_ivars)
+        # Detect "render :other_template" and include those templates' ivars too
+        rendered = ctrl_text.scan(/render\s+:(\w+)/).flatten.uniq
+        other_templates = rendered.reject { |t| t == action_name }
+        other_templates.each do |tmpl|
+          view_ivars.merge(extract_ivars_from_view_text(view_text, action: tmpl))
+        end
+        ivar_check = cross_reference_ivars(ctrl_ivars, view_ivars, rendered_templates: other_templates)
         lines << "" << ivar_check if ivar_check
 
         text_response(lines.join("\n"))
@@ -140,13 +148,13 @@ module RailsAiContext
         ivars
       end
 
-      private_class_method def self.cross_reference_ivars(ctrl_ivars, view_ivars)
+      private_class_method def self.cross_reference_ivars(ctrl_ivars, view_ivars, rendered_templates: [])
         return nil if ctrl_ivars.empty? && view_ivars.empty?
 
         lines = [ "## Instance Variable Cross-Check" ]
         all = (ctrl_ivars | view_ivars).sort
 
-        mismatches = false
+        missing_ivars = []
         all.each do |ivar|
           in_ctrl = ctrl_ivars.include?(ivar)
           in_view = view_ivars.include?(ivar)
@@ -154,13 +162,21 @@ module RailsAiContext
             lines << "- \u2713 @#{ivar} — set in controller, used in view"
           elsif in_view && !in_ctrl
             lines << "- \u2717 @#{ivar} — used in view but NOT set in controller"
-            mismatches = true
+            missing_ivars << ivar
           elsif in_ctrl && !in_view
             lines << "- \u26A0 @#{ivar} — set in controller but not used in view"
           end
         end
 
-        mismatches || all.any? ? lines.join("\n") : nil
+        # If there are missing ivars AND this action renders another template,
+        # add a note explaining why — the other action likely sets them
+        if missing_ivars.any? && rendered_templates.any?
+          templates = rendered_templates.map { |t| "`#{t}`" }.join(", ")
+          lines << ""
+          lines << "_Note: This action renders #{templates} on failure — those ivars are likely set in the corresponding action(s)._"
+        end
+
+        (missing_ivars.any? || all.any?) ? lines.join("\n") : nil
       end
 
       private_class_method def self.controller_context(controller_name)
@@ -215,7 +231,11 @@ module RailsAiContext
 
         if key && models[key][:table_name]
           schema_result = GetSchema.call(table: models[key][:table_name])
-          lines << "" << "---" << "" << schema_result.content.first[:text]
+          schema_text = schema_result.content.first[:text]
+          # Only append schema if it actually has useful data (not "not found")
+          unless schema_text.include?("not found") || schema_text.include?("Available:")
+            lines << "" << "---" << "" << schema_text
+          end
         end
 
         # Tests for this model
@@ -271,16 +291,58 @@ module RailsAiContext
         ctx = begin; cached_context; rescue; nil; end
         if ctx
           models = ctx[:models] || {}
+          matched_tables = Set.new
+
           models.each_key do |model_name|
             next unless model_name.downcase.include?(feature_name.downcase)
             table_name = models[model_name][:table_name]
             next unless table_name
+            matched_tables << table_name
             schema_result = GetSchema.call(table: table_name)
             schema_text = schema_result.content.first[:text]
             unless schema_text.include?("not found")
               lines << "" << "---" << "" << schema_text
             end
           end
+
+          # Also include schema for related models (associated tables) if the
+          # primary model was found but the feature analysis missed controllers/services
+          analyze_text = analyze_result.content.first[:text]
+          has_controllers = analyze_text.include?("## Controllers")
+          unless has_controllers
+            # Check if any controllers or services reference this feature by name
+            controllers = ctx[:controllers]
+            if controllers.is_a?(Hash) && !controllers[:error]
+              related_ctrls = (controllers[:controllers] || []).select do |c|
+                c_name = c[:name] || ""
+                c_name.downcase.include?(feature_name.downcase) ||
+                  c_name.downcase.include?(feature_name.singularize.downcase) ||
+                  c_name.downcase.include?(feature_name.pluralize.downcase)
+              end
+              if related_ctrls.any?
+                lines << "" << "## Related Controllers (by name)"
+                related_ctrls.each do |c|
+                  actions = (c[:actions] || []).map { |a| a.is_a?(Hash) ? a[:name] : a }.compact
+                  lines << "- **#{c[:name]}** — #{actions.join(', ')}"
+                end
+              end
+            end
+
+            # Check services
+            services = ctx[:services] || ctx[:service_objects]
+            if services.is_a?(Hash) && !services[:error]
+              service_list = services[:services] || []
+              related_svcs = service_list.select do |s|
+                s_name = (s[:name] || s[:file] || "").to_s
+                s_name.downcase.include?(feature_name.downcase) ||
+                  s_name.downcase.include?(feature_name.singularize.downcase)
+              end
+              if related_svcs.any?
+                lines << "" << "## Related Services (by name)"
+                related_svcs.each { |s| lines << "- `#{s[:file] || s[:name]}`" }
+              end
+            end
+          end
         end
 
         text_response(lines.join("\n"))

data/lib/rails_ai_context/tools/get_conventions.rb

@@ -74,6 +74,13 @@ module RailsAiContext
           end
         end
 
+        # I18n / Locale info
+        locale_info = detect_locale_info
+        if locale_info.any?
+          lines << "" << "## I18n"
+          locale_info.each { |l| lines << "- #{l}" }
+        end
+
         # Convention Fingerprint — one-paragraph summary of the app's detected conventions
         fingerprint_parts = []
         fingerprint_parts << conventions[:architecture].map { |a| humanize_arch(a) }.join(", ") if conventions[:architecture]&.any?
@@ -319,6 +326,58 @@ module RailsAiContext
         [] # Graceful degradation — never break the tool
       end
 
+      private_class_method def self.detect_locale_info
+        info = []
+        locales_dir = Rails.root.join("config", "locales")
+        return info unless Dir.exist?(locales_dir)
+
+        locale_files = Dir.glob(File.join(locales_dir, "**", "*.{yml,yaml,rb}"))
+        locales = locale_files.map { |f| File.basename(f, ".*").split(".").first }.uniq.sort
+
+        return info if locales.empty?
+
+        info << "**Locales:** #{locales.join(', ')} (#{locales.size} total)"
+
+        # Detect default locale from config
+        app_config = Rails.root.join("config", "application.rb")
+        if File.exist?(app_config)
+          content = File.read(app_config, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue ""
+          if (match = content.match(/config\.i18n\.default_locale\s*=\s*[:"'](\w+)/))
+            info << "**Default locale:** #{match[1]}"
+          end
+        end
+
+        # Detect primary UI language by sampling flash messages from controllers
+        controllers_dir = Rails.root.join("app", "controllers")
+        if Dir.exist?(controllers_dir)
+          samples = []
+          Dir.glob(File.join(controllers_dir, "**", "*.rb")).first(10).each do |path|
+            content = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue next
+            content.scan(/(?:notice|alert|flash\[:\w+\]):\s*"([^"]+)"/).each { |m| samples << m[0] }
+          end
+          if samples.any?
+            # Check if majority contains non-ASCII (CJK, Korean, etc.)
+            non_ascii = samples.count { |s| s.match?(/[^\x00-\x7F]/) }
+            ratio = non_ascii.to_f / samples.size
+            if ratio > 0.5
+              if samples.any? { |s| s.match?(/[\uAC00-\uD7AF]/) }
+                info << "**Primary UI language:** Korean (detected from flash messages)"
+              elsif samples.any? { |s| s.match?(/[\u4E00-\u9FFF]/) }
+                info << "**Primary UI language:** Chinese (detected from flash messages)"
+              elsif samples.any? { |s| s.match?(/[\u3040-\u309F\u30A0-\u30FF]/) }
+                info << "**Primary UI language:** Japanese (detected from flash messages)"
+              else
+                info << "**Primary UI language:** non-English (detected from flash messages)"
+              end
+            end
+          end
+        end
+
+        info
+      rescue
+        []
+      end
+
       private_class_method def self.detect_test_pattern
         sections = []
         test_dir = Rails.root.join("test", "controllers")

data/lib/rails_ai_context/tools/get_design_system.rb

@@ -89,16 +89,27 @@ module RailsAiContext
           end
         end
 
-        # ViewComponents
+        # ViewComponents — grouped by category
         if cached_context[:components].is_a?(Hash) && !cached_context[:components][:error] && cached_context[:components][:components]&.any?
           comp_data = cached_context[:components][:components]
-          lines << "## Components" << ""
-          comp_data.first(15).each do |c|
-            slots = c[:slots]&.size || 0
-            slot_info = slots > 0 ? " (#{slots} slots)" : ""
-            lines << "- **#{c[:name]}**#{slot_info}"
+
+          # Group components by inferred category from file path or name
+          grouped = comp_data.group_by { |c| categorize_component(c) }
+          lines << "## Components (#{comp_data.size})" << ""
+
+          grouped.sort_by { |cat, _| cat }.each do |category, comps|
+            lines << "### #{category}"
+            comps.each do |c|
+              slots = c[:slots]&.size || 0
+              props = c[:props]&.size || 0
+              meta = []
+              meta << "#{slots} slots" if slots > 0
+              meta << "#{props} props" if props > 0
+              meta_str = meta.any? ? " (#{meta.join(', ')})" : ""
+              lines << "- **#{c[:name]}**#{meta_str}"
+            end
+            lines << ""
           end
-          lines << ""
         end
 
         # Accessibility
@@ -494,6 +505,33 @@ module RailsAiContext
           lines
         end
 
+        def categorize_component(component)
+          file = (component[:file] || "").downcase
+          name = (component[:name] || "").downcase
+
+          # Categorize by directory structure first
+          if file.include?("/ruby_ui/") || file.include?("/ui/")
+            # Sub-categorize UI primitives
+            return "UI / Form" if name.match?(/input|select|textarea|form|radio|checkbox/)
+            return "UI / Feedback" if name.match?(/alert|toast|dialog|modal/)
+            return "UI / Navigation" if name.match?(/breadcrumb|pagination|nav|link|menu|tabs/)
+            return "UI / Layout" if name.match?(/card|separator|heading|text|badge/)
+            return "UI / Media" if name.match?(/avatar|carousel|image/)
+            return "UI / Overlay" if name.match?(/dialog|popover|tooltip|dropdown/)
+            return "UI / Primitives"
+          end
+
+          return "Domain / Articles" if name.match?(/article/)
+          return "Domain / Comments" if name.match?(/comment/)
+          return "Domain / Posts" if name.match?(/post/)
+          return "Domain / Users" if name.match?(/user|profile/)
+          return "Domain / Likes" if name.match?(/like/)
+          return "Domain / Tags" if name.match?(/tag/)
+          return "Layout" if name.match?(/layout|flash|pagination|sidebar|login/)
+
+          "Other"
+        end
+
         # Safe key extraction — handles both Hash and Array
         def safe_keys(value, limit = nil)
           names = value.is_a?(Hash) ? value.keys : Array(value)

data/lib/rails_ai_context/tools/get_edit_context.rb

@@ -146,9 +146,10 @@ module RailsAiContext
       private_class_method def self.sensitive_file?(relative_path)
         patterns = RailsAiContext.configuration.sensitive_patterns
         basename = File.basename(relative_path)
+        flags = File::FNM_DOTMATCH | File::FNM_CASEFOLD
         patterns.any? do |pattern|
-          File.fnmatch(pattern, relative_path, File::FNM_DOTMATCH) ||
-            File.fnmatch(pattern, basename, File::FNM_DOTMATCH)
+          File.fnmatch(pattern, relative_path, flags) ||
+            File.fnmatch(pattern, basename, flags)
         end
       end
 

data/lib/rails_ai_context/tools/get_env.rb

@@ -141,16 +141,42 @@ module RailsAiContext
       private_class_method def self.format_full(env_vars, env_example, dockerfile_vars, external_services, credentials_keys, encrypted_columns, root)
         lines = [ "# Environment Configuration (Full Detail)", "" ]
 
-        # ENV vars with per-file locations
+        # ENV vars grouped by category with file annotations
         if env_vars.any?
-          lines << "## Environment Variables by File"
+          lines << "## Environment Variables by Category"
+
+          # Build a map: var_name -> { details from all files }
+          var_details = {}
           env_vars.sort_by { |file, _| file }.each do |file, vars|
             relative = file.sub("#{root}/", "")
-            lines << "" << "### `#{relative}`"
+            vars.each do |v|
+              var_details[v[:name]] ||= { files: [], default: nil }
+              var_details[v[:name]][:files] << { file: relative, line: v[:line] }
+              var_details[v[:name]][:default] ||= v[:default]
+            end
+          end
+
+          # Group by category
+          categorized = Hash.new { |h, k| h[k] = [] }
+          var_details.each do |name, details|
+            category = categorize_env_var(name)
+            categorized[category] << { name: name, **details }
+          end
+
+          category_order = [
+            "API Keys & Secrets", "Mail", "Database", "Infrastructure",
+            "Monitoring", "Push Notifications", "Other"
+          ]
+          sorted_categories = categorized.keys.sort_by { |k| category_order.index(k) || 99 }
+
+          sorted_categories.each do |category|
+            vars = categorized[category]
+            lines << "" << "### #{category}"
             vars.sort_by { |v| v[:name] }.each do |v|
+              file_locations = v[:files].map { |f| f[:line] ? "#{f[:file]}:#{f[:line]}" : f[:file] }.uniq
               entry = "- `#{v[:name]}`"
-              entry += " (fetch, default: `#{v[:default]}`)" if v[:default]
-              entry += " — line #{v[:line]}" if v[:line]
+              entry += " (default: `#{v[:default]}`)" if v[:default]
+              entry += " (#{file_locations.join(', ')})"
               lines << entry
             end
           end
@@ -539,30 +565,30 @@ module RailsAiContext
         encrypted
       end
 
+      private_class_method def self.categorize_env_var(name)
+        case name
+        when /API_KEY|SECRET|TOKEN/i then "API Keys & Secrets"
+        when /MAIL|IMAP|SMTP/i then "Mail"
+        when /DATABASE|DB_|REDIS/i then "Database"
+        when /OTEL|SENTRY|DATADOG|NEWRELIC|APPSIGNAL/i then "Monitoring"
+        when /PUSH|VAPID|FCM/i then "Push Notifications"
+        when /PORT|CONCURRENCY|THREADS|WORKERS|TIMEOUT|QUEUE|PIDFILE/i then "Infrastructure"
+        else "Other"
+        end
+      end
+
       private_class_method def self.group_env_vars(var_names)
         groups = Hash.new { |h, k| h[k] = [] }
 
         var_names.each do |name|
-          group = case name
-          when /\ADATABASE_|_DB_|_DATABASE/ then "Database"
-          when /\AREDIS_|_REDIS/ then "Redis"
-          when /\AAWS_|_S3_|_SES_/ then "AWS"
-          when /\ASTRIPE_/ then "Payments (Stripe)"
-          when /\ATWILIO_/ then "Twilio"
-          when /\ASENDGRID_|_SMTP_|_MAILER_|_MAIL_/ then "Email"
-          when /\ASENTRY_|_BUGSNAG_|_ROLLBAR_|_NEWRELIC_|_DD_/ then "Monitoring"
-          when /\AOAUTH_|_CLIENT_ID|_CLIENT_SECRET|_API_KEY/ then "API Keys & Auth"
-          when /\ARAILS_|_ENV\z|_HOST|_PORT|_URL\z/ then "App Configuration"
-          when /\ARECAPTCHA_/ then "Security"
-          when /\ASECRET_|_TOKEN|_KEY\z/ then "Secrets"
-          else "Other"
-          end
-
-          groups[group] << name
+          groups[categorize_env_var(name)] << name
         end
 
         # Sort groups: important ones first
-        priority = %w[App\ Configuration Database Redis AWS Payments\ (Stripe) Email API\ Keys\ &\ Auth Monitoring Security Secrets Other]
+        priority = [
+          "API Keys & Secrets", "Mail", "Database", "Infrastructure",
+          "Monitoring", "Push Notifications", "Other"
+        ]
         groups.sort_by { |k, _| priority.index(k) || 99 }
       end
 
@@ -603,10 +629,11 @@ module RailsAiContext
         relative = file.sub("#{root}/", "")
         basename = File.basename(relative)
         patterns = RailsAiContext.configuration.sensitive_patterns
+        flags = File::FNM_DOTMATCH | File::FNM_CASEFOLD
 
         patterns.any? do |pattern|
-          File.fnmatch(pattern, relative, File::FNM_DOTMATCH) ||
-            File.fnmatch(pattern, basename, File::FNM_DOTMATCH)
+          File.fnmatch(pattern, relative, flags) ||
+            File.fnmatch(pattern, basename, flags)
         end
       end
 

data/lib/rails_ai_context/tools/get_frontend_stack.rb

@@ -49,22 +49,61 @@ module RailsAiContext
 
         def build_summary(data)
           parts = []
-          parts << "#{data[:framework]}#{version_suffix(data[:version])}" if data[:framework]
-          parts << data[:mounting_strategy] if data[:mounting_strategy]
-          parts << data[:build_tool] if data[:build_tool]
+          parts << "#{data[:framework]}#{version_suffix(data[:version])}" if data[:framework].present?
+          parts << data[:mounting_strategy] if data[:mounting_strategy].present?
+          parts << data[:build_tool] if data[:build_tool].present?
 
           if data[:typescript].is_a?(Hash) && data[:typescript][:enabled]
             parts << "TypeScript"
           end
 
-          parts << data[:state_management] if data[:state_management]
+          if data[:state_management].is_a?(String) && data[:state_management].present?
+            parts << data[:state_management]
+          elsif data[:state_management].is_a?(Array) && data[:state_management].any?
+            parts << data[:state_management].join(", ")
+          end
 
           total = total_component_count(data)
           parts << "(#{total} components)" if total > 0
 
+          # If no JS framework data, try building a Hotwire summary from cached context
+          if parts.empty?
+            hotwire = build_hotwire_summary
+            return hotwire if hotwire
+          end
+
           parts.any? ? parts.join(" + ") : "No frontend framework detected."
         end
 
+        def build_hotwire_summary
+          stimulus = cached_context[:stimulus]
+          gems = cached_context[:gems]
+
+          notable = gems.is_a?(Hash) && !gems[:error] ? (gems[:notable_gems] || []) : []
+          has_turbo = notable.any? { |g| g[:name] == "turbo-rails" }
+          has_stimulus = notable.any? { |g| g[:name] == "stimulus-rails" }
+          has_importmap = notable.any? { |g| g[:name] == "importmap-rails" }
+          has_tailwind = notable.any? { |g| g[:name] == "tailwindcss-rails" }
+
+          return nil unless has_turbo || has_stimulus
+
+          parts = []
+          parts << "Hotwire (Turbo + Stimulus)" if has_turbo && has_stimulus
+          parts << "Hotwire (Turbo)" if has_turbo && !has_stimulus
+          parts << "Hotwire (Stimulus)" if !has_turbo && has_stimulus
+
+          parts << "with importmap-rails" if has_importmap
+
+          if stimulus.is_a?(Hash) && !stimulus[:error]
+            count = stimulus[:total_controllers] || stimulus[:controllers]&.size || 0
+            parts << "#{count} Stimulus controllers" if count > 0
+          end
+
+          parts << "Tailwind CSS" if has_tailwind
+
+          parts.join(", ")
+        end
+
         def build_standard(data)
           lines = [ "# Frontend Stack", "" ]
 
@@ -90,12 +129,25 @@ module RailsAiContext
             lines << "- **Testing:** #{data[:testing_frameworks].join(', ')}"
           end
 
-          # Frontend roots with component counts
+          # Hotwire stack — enrich with Stimulus/Turbo data for importmap apps
+          enrich_with_hotwire(lines)
+
+          # Frontend roots with component counts — skip "0 components" for Hotwire apps
+          # where Stimulus controllers ARE the components
+          has_hotwire = lines.any? { |l| l.include?("Hotwire Stack") }
           if data[:frontend_roots].is_a?(Array) && data[:frontend_roots].any?
-            lines << "" << "## Frontend Roots" << ""
-            data[:frontend_roots].each do |root|
-              count = root[:component_count] || 0
-              lines << "- `#{root[:path]}` — #{count} components"
+            roots_with_components = data[:frontend_roots].select { |r| (r[:component_count] || 0) > 0 }
+            if roots_with_components.any?
+              lines << "" << "## Frontend Roots" << ""
+              roots_with_components.each do |root|
+                lines << "- `#{root[:path]}` — #{root[:component_count]} components"
+              end
+            elsif !has_hotwire
+              # Only show "0 components" for non-Hotwire apps where it's meaningful
+              lines << "" << "## Frontend Roots" << ""
+              data[:frontend_roots].each do |root|
+                lines << "- `#{root[:path]}` — 0 components"
+              end
             end
           end
 
@@ -154,6 +206,45 @@ module RailsAiContext
             0
           end
         end
+
+        # For Hotwire/importmap apps, pull Stimulus and Turbo data from context
+        def enrich_with_hotwire(lines)
+          stimulus = cached_context[:stimulus]
+          turbo = cached_context[:turbo]
+          gems = cached_context[:gems]
+
+          # Check if this is a Hotwire app (has turbo-rails or stimulus-rails)
+          notable = gems.is_a?(Hash) && !gems[:error] ? (gems[:notable_gems] || []) : []
+          has_turbo = notable.any? { |g| g[:name] == "turbo-rails" }
+          has_stimulus = notable.any? { |g| g[:name] == "stimulus-rails" }
+          has_importmap = notable.any? { |g| g[:name] == "importmap-rails" }
+
+          return unless has_turbo || has_stimulus
+
+          lines << ""
+          lines << "## Hotwire Stack"
+          lines << ""
+          lines << "- **Turbo:** turbo-rails (Drive, Frames, Streams)" if has_turbo
+          lines << "- **Stimulus:** stimulus-rails" if has_stimulus
+          lines << "- **Asset delivery:** importmap-rails (no JS bundler)" if has_importmap
+
+          if stimulus.is_a?(Hash) && !stimulus[:error]
+            count = stimulus[:total_controllers] || stimulus[:controllers]&.size || 0
+            if count > 0
+              names = (stimulus[:controllers] || []).map { |c| c[:name] || c[:file]&.gsub("_controller.js", "") }.compact.sort
+              lines << "- **Stimulus controllers:** #{count} (#{names.first(8).join(', ')}#{count > 8 ? ', ...' : ''})"
+            end
+          end
+
+          if turbo.is_a?(Hash) && !turbo[:error]
+            broadcasts = turbo[:broadcasts]&.size || turbo[:explicit_broadcasts]&.size || 0
+            frames = turbo[:frames]&.size || 0
+            parts = []
+            parts << "#{broadcasts} broadcasts" if broadcasts > 0
+            parts << "#{frames} frames" if frames > 0
+            lines << "- **Turbo wiring:** #{parts.join(', ')}" if parts.any?
+          end
+        end
       end
     end
   end

data/lib/rails_ai_context/tools/get_model_details.rb

@@ -123,6 +123,25 @@ module RailsAiContext
           lines << "**Structure:** #{map}"
         end
 
+        # Schema columns — inline from schema introspection
+        if data[:table_name]
+          schema = cached_context[:schema]
+          if schema.is_a?(Hash) && !schema[:error] && schema[:tables]&.key?(data[:table_name])
+            table_data = schema[:tables][data[:table_name]]
+            cols = table_data[:columns] || []
+            if cols.any?
+              lines << "" << "## Columns"
+              cols.each do |c|
+                parts = [ "**#{c[:name]}**", c[:type] ]
+                parts << "NOT NULL" if c[:null] == false
+                parts << "default: #{c[:default]}" if c[:default] && !c[:default].to_s.empty?
+                parts << "array" if c[:array]
+                lines << "- #{parts.join(' | ')}"
+              end
+            end
+          end
+        end
+
         # Associations
         if data[:associations]&.any?
           lines << "" << "## Associations"

data/lib/rails_ai_context/tools/get_partial_interface.rb

@@ -212,7 +212,7 @@ module RailsAiContext
         prefixed_basename = basename.start_with?("_") ? basename : "_#{basename}"
         unprefixed_basename = basename.delete_prefix("_")
 
-        extensions = %w[.html.erb .erb .html.haml .haml .html.slim .slim]
+        extensions = %w[.html.erb .erb .html.haml .haml .html.slim .slim .rb .json.jbuilder .jbuilder .turbo_stream.erb]
         candidates = []
 
         # Try prefixed name with various extensions

data/lib/rails_ai_context/tools/get_stimulus.rb

@@ -17,7 +17,7 @@ module RailsAiContext
           detail: {
             type: "string",
             enum: %w[summary standard full],
-            description: "Detail level. summary: names + counts. standard: names + targets + actions (default). full: everything including values, outlets, classes."
+            description: "Detail level. summary: names + counts. standard: targets + values + actions (default). full: everything including outlets, classes, HTML usage."
           },
           limit: {
             type: "integer",
@@ -73,14 +73,19 @@ module RailsAiContext
 
         case detail
         when "summary"
-          active = controllers.select { |c| (c[:targets] || []).any? || (c[:actions] || []).any? }
-          empty = controllers.reject { |c| (c[:targets] || []).any? || (c[:actions] || []).any? }
+          active = controllers.select { |c| (c[:targets] || []).any? || (c[:actions] || []).any? || (c[:values].is_a?(Hash) ? c[:values] : {}).any? }
+          empty = controllers.reject { |c| (c[:targets] || []).any? || (c[:actions] || []).any? || (c[:values].is_a?(Hash) ? c[:values] : {}).any? }
 
           lines = [ "# Stimulus Controllers (#{total})", "" ]
           active.each do |ctrl|
             targets = (ctrl[:targets] || []).size
+            values = (ctrl[:values].is_a?(Hash) ? ctrl[:values] : {}).size
             actions = (ctrl[:actions] || []).size
-            lines << "- **#{ctrl[:name]}** — #{targets} targets, #{actions} actions"
+            parts = []
+            parts << "#{targets} targets" if targets > 0
+            parts << "#{values} values" if values > 0
+            parts << "#{actions} actions" if actions > 0
+            lines << "- **#{ctrl[:name]}** — #{parts.join(', ')}"
           end
           if empty.any?
             names = empty.map { |c| c[:name] }.join(", ")
@@ -90,13 +95,14 @@ module RailsAiContext
           text_response(lines.join("\n"))
 
         when "standard"
-          active = controllers.select { |c| (c[:targets] || []).any? || (c[:actions] || []).any? }
-          empty = controllers.reject { |c| (c[:targets] || []).any? || (c[:actions] || []).any? }
+          active = controllers.select { |c| (c[:targets] || []).any? || (c[:actions] || []).any? || (c[:values].is_a?(Hash) ? c[:values] : {}).any? }
+          empty = controllers.reject { |c| (c[:targets] || []).any? || (c[:actions] || []).any? || (c[:values].is_a?(Hash) ? c[:values] : {}).any? }
 
           lines = [ "# Stimulus Controllers (#{total})", "" ]
           active.each do |ctrl|
             lines << "## #{ctrl[:name]}"
             lines << "- Targets: #{(ctrl[:targets] || []).join(', ')}" if ctrl[:targets]&.any?
+            lines << "- Values: #{(ctrl[:values].is_a?(Hash) ? ctrl[:values] : {}).map { |k, v| "#{k} (#{v})" }.join(', ')}" if (ctrl[:values].is_a?(Hash) ? ctrl[:values] : {}).any?
             lines << "- Actions: #{(ctrl[:actions] || []).join(', ')}" if ctrl[:actions]&.any?
             if ctrl[:complexity].is_a?(Hash)
               parts = []
@@ -110,7 +116,7 @@ module RailsAiContext
           end
           if empty.any?
             names = empty.map { |c| c[:name] }.join(", ")
-            lines << "_Lifecycle only (no targets/actions): #{names}_"
+            lines << "_Lifecycle only (no targets/values/actions): #{names}_"
           end
 
           # Cross-controller composition