rails-ai-context 4.3.0 → 4.3.2

data/lib/rails_ai_context/serializers/tool_guide_helper.rb

@@ -24,20 +24,20 @@ module RailsAiContext
       end
 
       def tools_header
-        "## Tools (37) — MANDATORY, Use Before Read"
+        "## Tools (39) — MANDATORY, Use Before Read"
       end
 
       def tools_intro
         case tool_mode
         when :cli
           [
-            "This project has 37 introspection tools. **MANDATORY — use these instead of reading files.**",
+            "This project has 39 introspection tools. **MANDATORY — use these instead of reading files.**",
             "They return only relevant, structured data and save tokens. Read files ONLY when you are about to Edit them.",
             ""
           ]
         else
           [
-            "This project has 37 MCP tools via `rails ai:serve` (configured in `.mcp.json`).",
+            "This project has 39 MCP tools via `rails ai:serve` (configured in `.mcp.json`).",
             "**MANDATORY — use these instead of reading files.** They return structured data and save tokens.",
             "Read files ONLY when you are about to Edit them.",
             "If MCP tools are not connected, use CLI fallback: `#{cli_cmd("TOOL_NAME", "param=value")}`",
@@ -127,7 +127,7 @@ module RailsAiContext
           "",
           "- **Don't read db/schema.rb** — use `get_schema`. It adds [indexed]/[unique] hints you'd miss.",
           "- **Don't read model files for reference** — use `get_model_details`. It resolves concerns, inherited methods, and implicit belongs_to validations.",
-          "- **Don't use Grep/search agents** — use `#{search_tool}`. It excludes sensitive files, supports `match_type:\"trace\"`, and paginates.",
+          "- **Prefer `#{search_tool}` over Grep** for method tracing and cross-layer search. It excludes sensitive files, supports `match_type:\"trace\"`, and paginates.",
           "- **Don't call tools without a target** — `get_model_details()` without `model:` returns a paginated list, not an error. Always specify what you want.",
           "- **Don't skip validation** — run `#{validate_tool}` after EVERY edit. It catches syntax errors AND Rails-specific issues (missing partials, bad column refs).",
           "- **Don't ignore cross-references** — tool responses include `_Next:` hints suggesting the best follow-up call. Follow them.",
@@ -144,7 +144,7 @@ module RailsAiContext
             "",
             "1. **Use composite tools first** — `#{cli_cmd("context")}` and `#{cli_cmd("analyze_feature")}` before individual tools",
             "2. **NEVER read reference files** — db/schema.rb, config/routes.rb, model files, test files — tools are better",
-            "3. **NEVER use Grep** — use `#{cli_cmd("search_code")}`",
+            "3. **Prefer `#{cli_cmd("search_code")}`** for tracing and cross-layer search — standard search tools are fine for simple targeted lookups",
             "4. **Read files ONLY to Edit them** — not for reference",
             "5. **Validate EVERY edit** — `#{cli_cmd("validate", "files=... level=rails")}`",
             "6. **Follow _Next:_ hints** — tool responses suggest the best follow-up call",
@@ -156,7 +156,7 @@ module RailsAiContext
             "",
             "1. **Use composite tools first** — `rails_get_context` and `rails_analyze_feature` before individual tools",
             "2. **NEVER read reference files** — db/schema.rb, config/routes.rb, model files, test files — tools are better",
-            "3. **NEVER use Grep** — use `rails_search_code`",
+            "3. **Prefer `rails_search_code`** for tracing and cross-layer search — standard search tools are fine for simple targeted lookups",
             "4. **Read files ONLY to Edit them** — not for reference",
             "5. **Validate EVERY edit** — `rails_validate(files:[...], level:\"rails\")`",
             "6. **Follow _Next:_ hints** — tool responses suggest the best follow-up call",
@@ -167,7 +167,7 @@ module RailsAiContext
       end
 
       def tools_table # rubocop:disable Metrics/MethodLength
-        lines = [ "### All 37 Tools", "" ]
+        lines = [ "### All 39 Tools", "" ]
 
         if tool_mode == :cli
           lines.concat(tools_table_cli)
@@ -218,7 +218,9 @@ module RailsAiContext
           "| `rails_generate_test(model:\"X\")` | `#{cli_cmd("generate_test", "model=X")}` | Generate test scaffolding matching project patterns (framework, factories, style) |",
           "| `rails_diagnose(error:\"X\")` | `#{cli_cmd("diagnose", "error=\"X\"")}` | One-call error diagnosis: context + git changes + logs + fix suggestions |",
           "| `rails_review_changes(ref:\"main\")` | `#{cli_cmd("review_changes", "ref=main")}` | PR/commit review: file context + warnings (missing indexes, removed validations) |",
-          "| `rails_onboard(detail:\"standard\")` | `#{cli_cmd("onboard", "detail=standard")}` | Narrative app walkthrough for new developers or AI agents |"
+          "| `rails_onboard(detail:\"standard\")` | `#{cli_cmd("onboard", "detail=standard")}` | Narrative app walkthrough for new developers or AI agents |",
+          "| `rails_runtime_info(detail:\"standard\")` | `#{cli_cmd("runtime_info", "detail=standard")}` | Live runtime: DB pool, table sizes, cache stats, job queues, pending migrations |",
+          "| `rails_session_context(action:\"status\")` | `#{cli_cmd("session_context", "action=status")}` | Track what you've already queried, avoid redundant calls |"
         ]
       end
 
@@ -262,7 +264,9 @@ module RailsAiContext
           "| `#{cli_cmd("generate_test", "model=X")}` | Generate test scaffolding matching project patterns (framework, factories, style) |",
           "| `#{cli_cmd("diagnose", "error=\"X\"")}` | One-call error diagnosis: context + git changes + logs + fix suggestions |",
           "| `#{cli_cmd("review_changes", "ref=main")}` | PR/commit review: file context + warnings (missing indexes, removed validations) |",
-          "| `#{cli_cmd("onboard", "detail=standard")}` | Narrative app walkthrough for new developers or AI agents |"
+          "| `#{cli_cmd("onboard", "detail=standard")}` | Narrative app walkthrough for new developers or AI agents |",
+          "| `#{cli_cmd("runtime_info", "detail=standard")}` | Live runtime: DB pool, table sizes, cache stats, job queues, pending migrations |",
+          "| `#{cli_cmd("session_context", "action=status")}` | Track what you've already queried, avoid redundant calls |"
         ]
       end
 
@@ -290,6 +294,7 @@ module RailsAiContext
         lines.concat(tools_intro)
         lines.concat(tools_power_tool_section)
         lines.concat(tools_workflow_section)
+        lines.concat(tools_antipatterns_section)
         lines.concat(tools_rules_section)
         lines.concat(tools_name_list)
         lines
@@ -309,6 +314,7 @@ module RailsAiContext
           rails_migration_advisor rails_get_frontend_stack rails_search_docs
           rails_query rails_read_logs rails_generate_test rails_diagnose
           rails_review_changes rails_onboard
+          rails_runtime_info rails_session_context
         ]
         [
           "### All #{all_tools.size} tools",

data/lib/rails_ai_context/server.rb

@@ -45,7 +45,9 @@ module RailsAiContext
       Tools::GenerateTest,
       Tools::Diagnose,
       Tools::ReviewChanges,
-      Tools::Onboard
+      Tools::Onboard,
+      Tools::RuntimeInfo,
+      Tools::SessionContext
     ].freeze
 
     def initialize(app, transport: :stdio)
@@ -117,6 +119,11 @@ module RailsAiContext
       # Build a minimal Rack app that delegates to the MCP transport
       rack_app = build_rack_app(transport, config.http_path)
 
+      unless config.http_bind == "127.0.0.1" || config.http_bind == "::1" || config.http_bind == "localhost"
+        $stderr.puts "[rails-ai-context] WARNING: MCP HTTP transport binding to #{config.http_bind} — " \
+                     "this exposes all tools to the network without authentication. " \
+                     "Use 127.0.0.1 (default) unless you have external auth in place."
+      end
       $stderr.puts "[rails-ai-context] MCP server starting on #{config.http_bind}:#{config.http_port}#{config.http_path}"
       $stderr.puts "[rails-ai-context] Tools: #{TOOLS.map { |t| t.tool_name }.join(', ')}"
       maybe_start_live_reload(server)

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -21,9 +21,14 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
+      # Map well-known feature keywords to gem-based patterns
+      AUTH_KEYWORDS = %w[auth authentication login signup signin session devise omniauth].freeze
+      AUTH_GEM_NAMES = %w[devise omniauth rodauth sorcery clearance authlogic warden jwt].freeze
+
       def self.call(feature:, server_context: nil) # rubocop:disable Metrics
         feature = feature.to_s.strip
         return text_response("Please provide a feature keyword (e.g. 'cook', 'payment', 'authentication').") if feature.empty?
+        set_call_params(feature: feature)
 
         ctx = cached_context
         pattern = feature.downcase
@@ -48,6 +53,19 @@ module RailsAiContext
         discover_accessibility(ctx, pattern, lines)
         discover_components(ctx, pattern, lines)
 
+        # For auth-related keywords, also discover auth gems
+        if AUTH_KEYWORDS.include?(pattern)
+          gems = ctx[:gems]
+          if gems.is_a?(Hash) && !gems[:error]
+            notable = gems[:notable_gems] || []
+            auth_gems = notable.select { |g| AUTH_GEM_NAMES.include?(g[:name]) }
+            if auth_gems.any?
+              lines << "" << "## Auth Gems" << ""
+              auth_gems.each { |g| lines << "- **#{g[:name]}** #{g[:version]}#{g[:config] ? " (config: #{g[:config]})" : ""}" }
+            end
+          end
+        end
+
         # If nothing was discovered, return a clean "no match" with real suggestions
         has_content = lines.any? { |l| l.start_with?("## ") || l.start_with?("### ") }
         unless has_content
@@ -65,11 +83,16 @@ module RailsAiContext
         # --- AF: Models ---
         def discover_models(ctx, pattern, lines)
           models = ctx[:models] || {}
+
+          # For auth-related keywords, also match the User model and auth-related concerns
+          extra_auth_match = AUTH_KEYWORDS.include?(pattern)
+
           matched = models.select do |name, data|
             next false if data[:error]
             name.downcase.include?(pattern) ||
               data[:table_name]&.downcase&.include?(pattern) ||
-              name.underscore.include?(pattern)
+              name.underscore.include?(pattern) ||
+              (extra_auth_match && (name == "User" || data[:concerns]&.any? { |c| c.to_s.downcase.match?(/authenticat|devise/) }))
           end
 
           if matched.any?

data/lib/rails_ai_context/tools/base_tool.rb

@@ -12,6 +12,11 @@ module RailsAiContext
       # for thread safety in multi-threaded servers (e.g., Puma).
       SHARED_CACHE = { mutex: Mutex.new }
 
+      # Session-level context tracking. Lets AI avoid redundant queries
+      # by recording what tools have been called with what params.
+      # In-memory only — resets on server restart (matches conversation lifecycle).
+      SESSION_CONTEXT = { mutex: Mutex.new, queries: {} }
+
       class << self
         # Convenience: access the Rails app and cached introspection
         def rails_app
@@ -52,12 +57,62 @@ module RailsAiContext
         # Reset the shared cache. Used by LiveReload to invalidate on file change.
         def reset_all_caches!
           reset_cache!
+          session_reset!
+        end
+
+        # ── Session context helpers ──────────────────────────────────────
+
+        def session_record(tool_name, params, summary = nil)
+          SESSION_CONTEXT[:mutex].synchronize do
+            key = session_key(tool_name, params)
+            existing = SESSION_CONTEXT[:queries][key]
+            if existing
+              existing[:call_count] = (existing[:call_count] || 1) + 1
+              existing[:last_timestamp] = Time.now.iso8601
+              existing[:summary] = summary if summary
+            else
+              SESSION_CONTEXT[:queries][key] = {
+                tool: tool_name.to_s,
+                params: params,
+                call_count: 1,
+                timestamp: Time.now.iso8601,
+                summary: summary
+              }
+            end
+          end
+        end
+
+        def session_queried?(tool_name, **params)
+          SESSION_CONTEXT[:mutex].synchronize do
+            SESSION_CONTEXT[:queries].key?(session_key(tool_name, params))
+          end
+        end
+
+        def session_queries
+          SESSION_CONTEXT[:mutex].synchronize do
+            SESSION_CONTEXT[:queries].values.dup
+          end
+        end
+
+        def session_reset!
+          SESSION_CONTEXT[:mutex].synchronize do
+            SESSION_CONTEXT[:queries].clear
+          end
+        end
+
+        # Auto-compress: if text exceeds 85% of max, call the fallback lambda for a shorter version
+        def auto_compress(full_text, &fallback)
+          max = config.max_tool_response_chars
+          return full_text if !max || full_text.length <= (max * 0.85).to_i
+          fallback ? fallback.call : full_text
         end
 
         # Structured not-found error with fuzzy suggestion and recovery hint.
         # Helps AI agents self-correct without retrying blind.
         def not_found_response(type, name, available, recovery_tool: nil)
           suggestion = find_closest_match(name, available)
+          # Don't suggest the exact same string the user typed — that's useless
+          suggestion = nil if suggestion == name
           lines = [ "#{type} '#{name}' not found." ]
           lines << "Did you mean '#{suggestion}'?" if suggestion
           lines << "Available: #{available.first(20).join(', ')}#{"..." if available.size > 20}"
@@ -108,8 +163,22 @@ module RailsAiContext
           end
         end
 
-        # Helper: wrap text in an MCP::Tool::Response with safety-net truncation
+        # Store call params for the current tool invocation (thread-safe)
+        def set_call_params(**params)
+          Thread.current[:rails_ai_context_call_params] = params.reject { |_, v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        end
+
+        # Helper: wrap text in an MCP::Tool::Response with safety-net truncation.
+        # Auto-records the call in session context so session_context(action:"status") works.
         def text_response(text)
+          # Auto-track: record this tool call in session context (skip SessionContext itself to avoid recursion)
+          if respond_to?(:tool_name) && tool_name != "rails_session_context"
+            summary = text.lines.first&.strip&.truncate(80)
+            params = Thread.current[:rails_ai_context_call_params] || {}
+            session_record(tool_name, params, summary)
+            Thread.current[:rails_ai_context_call_params] = nil
+          end
+
           max = RailsAiContext.configuration.max_tool_response_chars
           if max && text.length > max
             truncated = text[0...max]
@@ -119,6 +188,14 @@ module RailsAiContext
             MCP::Tool::Response.new([ { type: "text", text: text } ])
           end
         end
+
+        private
+
+        def session_key(tool_name, params)
+          normalized = tool_name.to_s.sub(/\Arails_/, "")
+          param_str = params.is_a?(Hash) ? params.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}:#{v}" }.join(",") : params.to_s
+          "#{normalized}:#{param_str}"
+        end
       end
     end
   end

data/lib/rails_ai_context/tools/dependency_graph.rb

@@ -41,6 +41,8 @@ module RailsAiContext
         model = model.to_s.strip if model
         depth = [ [ depth.to_i, 1 ].max, 3 ].min
 
+        set_call_params(model: model, depth: depth, format: format)
+
         # Build adjacency list from model associations
         graph = build_graph(models_data)
 
@@ -48,7 +50,8 @@ module RailsAiContext
           # Filter to subgraph centered on the model
           model_key = find_model_key(model, graph.keys)
           unless model_key
-            return not_found_response("model", model, graph.keys, recovery_tool: "rails_dependency_graph")
+            return not_found_response("Model", model, graph.keys.sort,
+              recovery_tool: "Call rails_dependency_graph() without model to see all models")
           end
           subgraph = extract_subgraph(graph, model_key, depth)
         else

data/lib/rails_ai_context/tools/diagnose.rb

@@ -37,12 +37,34 @@ module RailsAiContext
 
       # ── Error classification ──────────────────────────────────────────
 
+      # Section size limits for output truncation
+      MAX_TOTAL_OUTPUT = 20_000
+      MAX_SECTION_CHARS = {
+        controller_context: 3_000,
+        model_context: 3_000,
+        code_context: 3_000,
+        schema_context: 3_000,
+        method_trace: 3_000,
+        git_changes: 2_000,
+        logs: 2_000
+      }.freeze
+
       ERROR_CLASSIFICATIONS = {
-        /NoMethodError|NameError/ => {
+        /NameError.*uninitialized constant/ => {
+          type: :name_error,
+          likely: "A class or module constant could not be found. This usually means a typo in the class/module name, a missing require, or an autoload issue.",
+          fix: "1. Check for typo in class/module name, missing require, or autoload issue\n2. Verify the file is in the correct autoload path (e.g. app/models, app/services)\n3. Run `rails_search_code(pattern:\"ClassName\", match_type:\"trace\")` to find where the constant is defined"
+        },
+        /NoMethodError/ => {
           type: :nil_reference,
           likely: "A method was called on nil or an undefined name was referenced. Check for: missing association, unfetched record, typo in method name.",
           fix: "1. Check the variable/object is not nil before calling the method\n2. Verify the association or attribute exists on the model\n3. Use `&.` safe navigation if the value can legitimately be nil"
         },
+        /NameError/ => {
+          type: :name_error,
+          likely: "An undefined name was referenced. This could be a typo in a variable, method, or constant name, or a missing require/autoload.",
+          fix: "1. Check for typo in class/module name, missing require, or autoload issue\n2. Verify the name is defined and accessible in the current scope\n3. Use `rails_search_code(pattern:\"name\", match_type:\"trace\")` to find where it is defined"
+        },
         /RecordNotFound/ => {
           type: :record_not_found,
           likely: "A `.find()` or `.find_by!()` call failed because the record doesn't exist. Common causes: stale URL, deleted record, wrong ID parameter.",
@@ -92,9 +114,11 @@ module RailsAiContext
         lines << "**Classification:** #{classification[:type]}"
         lines << ""
 
-        # Likely cause
+        # Likely cause — enriched with specific inference when possible
         lines << "## Likely Cause"
         lines << classification[:likely]
+        specific = infer_specific_cause(parsed, classification, file, action)
+        lines << "" << "**Specific:** #{specific}" if specific
         lines << ""
 
         # Suggested fix
@@ -103,14 +127,25 @@ module RailsAiContext
         lines << ""
 
         # Gather context based on parameters and error type
-        lines.concat(gather_context(parsed, classification, file, line, action))
+        context_sections = gather_context(parsed, classification, file, line, action)
 
         # Recent git changes
         git_section = gather_git_context(file, parsed[:file_refs])
-        lines.concat(git_section) if git_section.any?
 
         # Recent error logs
         log_section = gather_log_context(parsed[:exception_class])
+
+        # Truncate large sections before assembling final output
+        context_sections = truncate_section(context_sections, "Controller Context", MAX_SECTION_CHARS[:controller_context])
+        context_sections = truncate_section(context_sections, "Code Context", MAX_SECTION_CHARS[:code_context])
+        context_sections = truncate_section(context_sections, "Schema Context", MAX_SECTION_CHARS[:schema_context])
+        context_sections = truncate_section(context_sections, "Model Context", MAX_SECTION_CHARS[:model_context])
+        context_sections = truncate_section(context_sections, "Method Trace", MAX_SECTION_CHARS[:method_trace])
+        git_section = truncate_section(git_section, "Recent Git Changes", MAX_SECTION_CHARS[:git_changes])
+        log_section = truncate_section(log_section, "Recent Error Logs", MAX_SECTION_CHARS[:logs])
+
+        lines.concat(context_sections)
+        lines.concat(git_section) if git_section.any?
         lines.concat(log_section) if log_section.any?
 
         # Next steps
@@ -122,7 +157,14 @@ module RailsAiContext
           lines << "_Use `rails_search_code(pattern:\"#{parsed[:method_name]}\", match_type:\"trace\")` to trace the method._"
         end
 
-        text_response(lines.join("\n"))
+        output = lines.join("\n")
+
+        # Final safety cap: if total output still exceeds limit, hard-truncate
+        if output.length > MAX_TOTAL_OUTPUT
+          output = output[0, MAX_TOTAL_OUTPUT] + "\n\n_... output truncated (#{output.length} chars exceeded #{MAX_TOTAL_OUTPUT} limit)._"
+        end
+
+        text_response(output)
       rescue => e
         text_response("Diagnosis error: #{e.message}")
       end
@@ -223,7 +265,7 @@ module RailsAiContext
                   lines << text
                   lines << ""
                 end
-              rescue; end
+              rescue => e; $stderr.puts "[rails-ai-context] Diagnosis step skipped: #{e.message}"; end
             end
           end
 
@@ -242,7 +284,7 @@ module RailsAiContext
                   lines << text
                   lines << ""
                 end
-              rescue; end
+              rescue => e; $stderr.puts "[rails-ai-context] Diagnosis step skipped: #{e.message}"; end
             end
           end
 
@@ -256,12 +298,61 @@ module RailsAiContext
                 lines << text
                 lines << ""
               end
-            rescue; end
+            rescue => e; $stderr.puts "[rails-ai-context] Diagnosis step skipped: #{e.message}"; end
           end
 
           lines
         end
 
+        # Infer a specific diagnosis from the error + context
+        def infer_specific_cause(parsed, classification, file, action) # rubocop:disable Metrics
+          msg = parsed[:message].to_s
+          method = parsed[:method_name]
+
+          # "undefined method X for nil" — identify WHAT is nil
+          if classification[:type] == :nil_reference && msg.include?("for nil")
+            # Check if calling on current_user (common: auth not running)
+            if file&.include?("controller") && msg.match?(/current_user/)
+              return "`current_user` is nil — the `authenticate_user!` before_action may not be running for this route. " \
+                     "Check if this action is excluded via `unless:` or `skip_before_action`."
+            end
+            # Check if calling on an association
+            if method && file
+              begin
+                ctx = GetEditContext.call(file: file, near: method)
+                code = ctx.content.first[:text]
+                # Find the receiver: something.method_name
+                receiver_match = code.match(/(\w+)\.#{Regexp.escape(method)}/)
+                if receiver_match
+                  receiver = receiver_match[1]
+                  return "`#{receiver}` is nil when `.#{method}` is called. " \
+                         "This variable may not be set in all code paths — check if it's assigned before use, " \
+                         "or use `#{receiver}&.#{method}` for safe navigation."
+                end
+              rescue => e; $stderr.puts "[rails-ai-context] Diagnosis step skipped: #{e.message}"; end
+            end
+          end
+
+          # RecordNotFound — check if there's a set_* before_action
+          if classification[:type] == :record_not_found && action
+            ctrl, act = action.split("#", 2)
+            if ctrl && act
+              begin
+                ctrl_class = ctrl.end_with?("Controller") ? ctrl : "#{ctrl.camelize}Controller"
+                result = GetControllers.call(controller: ctrl_class, action: act)
+                text = result.content.first[:text]
+                if text.include?("set_") && text.include?("find")
+                  return "The `set_*` before_action uses `.find` which raises RecordNotFound. " \
+                         "The record with the given ID doesn't exist or doesn't belong to the current user. " \
+                         "Check if the record was deleted or if the user is authorized to access it."
+                end
+              rescue => e; $stderr.puts "[rails-ai-context] Diagnosis step skipped: #{e.message}"; end
+            end
+          end
+
+          nil
+        end
+
         def gather_git_context(file, file_refs)
           lines = []
           root = Rails.root.to_s
@@ -303,6 +394,42 @@ module RailsAiContext
             []
           end
         end
+
+        # Truncate the content of a named section (identified by "## heading") within a lines array.
+        # Returns a new array with the section's content lines truncated if they exceed max_chars.
+        def truncate_section(lines, heading, max_chars)
+          return lines if lines.empty? || max_chars.nil?
+
+          header_marker = "## #{heading}"
+          header_idx = lines.index(header_marker)
+          return lines unless header_idx
+
+          # Find the end of this section: next "## " header or end of array
+          section_end = nil
+          (header_idx + 1...lines.length).each do |i|
+            if lines[i].is_a?(String) && lines[i].start_with?("## ")
+              section_end = i
+              break
+            end
+          end
+          section_end ||= lines.length
+
+          # Measure content between header and section_end
+          content_lines = lines[(header_idx + 1)...section_end]
+          content = content_lines.join("\n")
+
+          return lines if content.length <= max_chars
+
+          # Truncate and rebuild
+          truncated_content = content[0, max_chars]
+          truncated_content += "\n\n_... section truncated (#{content.length} chars → #{max_chars} max)._"
+
+          result = lines[0...header_idx + 1]
+          result << truncated_content
+          result << ""
+          result.concat(lines[section_end..])
+          result
+        end
       end
     end
   end

data/lib/rails_ai_context/tools/generate_test.rb

@@ -264,12 +264,20 @@ module RailsAiContext
           lines << ""
           lines << "class #{name}Test < ActiveSupport::TestCase"
 
-          setup_var = factory ? "#{name.underscore}" : "#{name.underscore}"
+          setup_var = name.underscore
+          fixtures = tests_data[:fixtures]
+          fixture_names = tests_data[:fixture_names] || {}
+          # Determine data setup: factory > fixture > inline
+          lines << "  setup do"
           if factory
-            lines << "  setup do"
             lines << "    @#{setup_var} = create(:#{factory})"
-            lines << "  end"
+          elsif fixtures
+            fixture_key = resolve_fixture_key(name, fixture_names)
+            lines << "    @#{setup_var} = #{name.underscore.pluralize}(#{fixture_key})"
+          else
+            lines << "    @#{setup_var} = #{name}.new"
           end
+          lines << "  end"
 
           # Validations
           validations = data[:validations] || []
@@ -282,7 +290,29 @@ module RailsAiContext
                 next if seen.include?(key)
                 seen << key
                 lines << "  test \"validates #{v[:kind]} of #{attr}\" do"
-                lines << "    @#{setup_var}.#{attr} = nil" if v[:kind] == "presence"
+                case v[:kind]
+                when "presence"
+                  lines << "    @#{setup_var}.#{attr} = nil"
+                when "inclusion"
+                  lines << "    @#{setup_var}.#{attr} = \"__invalid_value__\""
+                when "uniqueness"
+                  lines << "    duplicate = @#{setup_var}.dup"
+                  lines << "    assert_not duplicate.valid?"
+                  lines << "  end"
+                  lines << ""
+                  next
+                when "numericality"
+                  lines << "    @#{setup_var}.#{attr} = \"not_a_number\""
+                when "length"
+                  max = v.dig(:options, :maximum)
+                  if max
+                    lines << "    @#{setup_var}.#{attr} = \"a\" * #{max + 1}"
+                  else
+                    lines << "    @#{setup_var}.#{attr} = \"\""
+                  end
+                when "format"
+                  lines << "    @#{setup_var}.#{attr} = \"invalid-format\""
+                end
                 lines << "    assert_not @#{setup_var}.valid?"
                 lines << "  end"
                 lines << ""
@@ -305,8 +335,18 @@ module RailsAiContext
           scopes = data[:scopes] || []
           scopes.each do |s|
             scope_name = s.is_a?(Hash) ? s[:name] : s
+            scope_body = s.is_a?(Hash) ? s[:body] : nil
             lines << "  test \"scope .#{scope_name} returns expected records\" do"
-            lines << "    # TODO: create test data and verify"
+            if scope_body&.include?("order")
+              lines << "    sql = #{name}.#{scope_name}.to_sql"
+              lines << "    assert_match(/ORDER BY/i, sql)"
+            elsif scope_body&.include?("where")
+              lines << "    results = #{name}.#{scope_name}"
+              lines << "    assert_kind_of ActiveRecord::Relation, results"
+            else
+              lines << "    results = #{name}.#{scope_name}"
+              lines << "    assert_kind_of ActiveRecord::Relation, results"
+            end
             lines << "  end"
             lines << ""
           end
@@ -431,10 +471,12 @@ module RailsAiContext
 
           has_devise = tests_data[:test_helper_setup]&.any? { |h| h.include?("Devise") }
           if has_devise
+            fixture_names = tests_data[:fixture_names] || {}
+            user_fixture_key = resolve_fixture_key("User", fixture_names)
             lines << "  include Devise::Test::IntegrationHelpers"
             lines << ""
             lines << "  setup do"
-            lines << "    @user = users(:one)"
+            lines << "    @user = users(#{user_fixture_key})"
             lines << "    sign_in @user"
             lines << "  end"
           end
@@ -444,9 +486,24 @@ module RailsAiContext
             path = r[:path] || "/#{snake}"
             verb = (r[:verb] || "GET").downcase
 
+            # Extract dynamic segments (e.g. :post_id, :id) from the path
+            param_names = path.scan(/:(\w+)/).flatten
+            quoted_path = path.gsub(/:(\w+)/, '#{\\1}')
+
             lines << ""
             lines << "  test \"#{r[:verb]} #{r[:path]} works\" do"
-            lines << "    #{verb} #{path.gsub(/:(\w+)/, '#{\\1}')}"
+            fixture_names = tests_data[:fixture_names] || {}
+            param_names.each do |param|
+              if param == "id"
+                fk = resolve_fixture_key(snake.singularize.camelize, fixture_names)
+                lines << "    #{param} = #{snake.pluralize}(#{fk}).id"
+              elsif param.end_with?("_id")
+                resource = param.delete_suffix("_id")
+                fk = resolve_fixture_key(resource.camelize, fixture_names)
+                lines << "    #{param} = #{resource.pluralize}(#{fk}).id"
+              end
+            end
+            lines << "    #{verb} \"#{quoted_path}\""
             lines << "    assert_response :success"
             lines << "  end"
           end
@@ -503,6 +560,29 @@ module RailsAiContext
 
         # ── Helpers ──────────────────────────────────────────────────────
 
+        # Resolve the best fixture key for a model by reading actual fixture file contents.
+        # Falls back to :one if no fixture file is found.
+        def resolve_fixture_key(model_name, fixture_names)
+          plural = model_name.underscore.pluralize
+          # fixture_names is { "users" => [:chef_one, :chef_two], "cooks" => [:pending_cook, ...] }
+          keys = fixture_names[plural] || fixture_names[plural.to_sym]
+          if keys.is_a?(Array) && keys.any?
+            ":#{keys.first}"
+          else
+            # Try reading the fixture file directly
+            fixture_file = File.join(Rails.root, "test", "fixtures", "#{plural}.yml")
+            if File.exist?(fixture_file)
+              content = File.read(fixture_file, encoding: "UTF-8", invalid: :replace, undef: :replace) rescue nil
+              if content
+                # YAML fixture files have top-level keys as fixture names
+                first_key = content.scan(/^([a-z_]\w*):/i).first&.first
+                return ":#{first_key}" if first_key
+              end
+            end
+            ":one"
+          end
+        end
+
         def find_factory_name(model_name, tests_data)
           factory_names = tests_data[:factory_names] || {}
           underscore = model_name.underscore