rails-ai-context 2.0.1 → 2.0.3

data/docs/GUIDE.md

@@ -561,31 +561,39 @@ Ripgrep-powered regex search across the codebase.
 
 | Param | Type | Description |
 |-------|------|-------------|
-| `pattern` | string | **Required.** Regex pattern to search for. |
+| `pattern` | string | **Required.** Regex pattern or method name to search for. |
 | `path` | string | Subdirectory to search in (e.g. `app/models`, `config`). Default: entire app. |
-| `file_type` | string | Filter by file type (e.g. `rb`, `erb`, `js`). Alphanumeric only. |
-| `match_type` | string | Filter matches: `any` (default), `definition` (only `def` lines), `class` (only `class`/`module` lines). |
+| `file_type` | string | Filter by file extension (e.g. `rb`, `erb`, `js`). Alphanumeric only. |
+| `match_type` | string | `any` (default), `definition` (def lines), `class` (class/module lines), `call` (call sites only), `trace` (**full picture** — definition with class context + source code + internal calls + sibling methods + callers with route chain + test coverage separated). |
 | `exact_match` | boolean | Match whole words only (wraps pattern in `\b` boundaries). Default: false. |
-| `max_results` | integer | Max results to return. Default: 30, max: 100. |
+| `exclude_tests` | boolean | Exclude test/spec/features directories. Default: false. |
+| `group_by_file` | boolean | Group results by file with match counts. Default: false. |
+| `offset` | integer | Skip this many results for pagination. Default: 0. |
 | `context_lines` | integer | Lines of context before and after each match (like grep -C). Default: 2, max: 5. |
 
+Smart result limiting: <10 results shows all, 10-100 shows half, >100 caps at 100. Use `offset` for pagination.
+
 **Examples:**
 
 ```
-rails_search_code(pattern: "has_secure_password")
-  → All files containing has_secure_password
+rails_search_code(pattern: "can_cook?", match_type: "trace")
+  → FULL PICTURE: definition with class context + source code + internal calls
+    + sibling methods + app callers with route chain + test coverage (separated)
+
+rails_search_code(pattern: "create", match_type: "definition")
+  → Only `def create` / `def self.create` lines
 
-rails_search_code(pattern: "class.*Controller", file_type: "rb")
-  → All Ruby files with controller class definitions
+rails_search_code(pattern: "can_cook", match_type: "call")
+  → Only call sites (excludes the definition)
 
-rails_search_code(pattern: "def create", file_type: "rb", max_results: 50)
-  → First 50 create methods across the codebase
+rails_search_code(pattern: "Controller", match_type: "class")
+  → All class/module definitions matching *Controller
 
-rails_search_code(pattern: "current_user", path: "app/controllers")
-  → Search only in app/controllers/
+rails_search_code(pattern: "has_many", group_by_file: true)
+  → Results grouped by file with match counts
 
-rails_search_code(pattern: "validates", context_lines: 3)
-  → Matches with 3 lines of context before and after (default is 2)
+rails_search_code(pattern: "cook", exclude_tests: true)
+  → Skip test/spec directories
 
 rails_search_code(pattern: "activate", match_type: "definition")
   → Only `def activate` / `def self.activate` lines (skips method calls)
@@ -1175,6 +1183,7 @@ end
 | `cache_ttl` | Integer | `60` | Cache TTL in seconds for introspection results |
 | `custom_tools` | Array | `[]` | Additional MCP tool classes to register alongside built-in tools |
 | `skip_tools` | Array | `[]` | Built-in tool names to exclude (e.g. `%w[rails_security_scan]`) |
+| `ai_tools` | Array | `nil` (all) | AI tools to generate context for: `%i[claude cursor copilot windsurf opencode]`. Selected during install. |
 | `excluded_models` | Array | internal Rails models | Models to skip |
 | `excluded_paths` | Array | `node_modules tmp log vendor .git` | Paths excluded from code search |
 | `sensitive_patterns` | Array | `.env`, `.key`, `.pem`, credentials | File patterns blocked from search and read tools |

data/lib/generators/rails_ai_context/install/install_generator.rb

@@ -9,6 +9,43 @@ module RailsAiContext
 
       desc "Install rails-ai-context: creates initializer, MCP config, and generates initial context files."
 
+      AI_TOOLS = {
+        "1" => { key: :claude,   name: "Claude Code",     files: "CLAUDE.md + .claude/rules/",                        format: :claude },
+        "2" => { key: :cursor,   name: "Cursor",          files: ".cursor/rules/",                                     format: :cursor },
+        "3" => { key: :copilot,  name: "GitHub Copilot",  files: ".github/copilot-instructions.md + .github/instructions/", format: :copilot },
+        "4" => { key: :windsurf, name: "Windsurf",        files: ".windsurfrules + .windsurf/rules/",                  format: :windsurf },
+        "5" => { key: :opencode, name: "OpenCode",        files: "AGENTS.md",                                          format: :opencode }
+      }.freeze
+
+      def select_ai_tools
+        say ""
+        say "Which AI tools do you use? (select all that apply)", :yellow
+        say ""
+        AI_TOOLS.each do |num, info|
+          say "  #{num}. #{info[:name].ljust(16)} → #{info[:files]}"
+        end
+        say "  a. All of the above"
+        say ""
+
+        input = ask("Enter numbers separated by commas (e.g. 1,2) or 'a' for all:").strip.downcase
+
+        @selected_formats = if input == "a" || input == "all"
+          AI_TOOLS.values.map { |t| t[:format] }
+        else
+          nums = input.split(/[\s,]+/)
+          nums.filter_map { |n| AI_TOOLS[n]&.dig(:format) }
+        end
+
+        if @selected_formats.empty?
+          say "No tools selected — defaulting to all.", :yellow
+          @selected_formats = AI_TOOLS.values.map { |t| t[:format] }
+        end
+
+        selected_names = AI_TOOLS.values.select { |t| @selected_formats.include?(t[:format]) }.map { |t| t[:name] }
+        say ""
+        say "Selected: #{selected_names.join(', ')}", :green
+      end
+
       def create_mcp_config
         mcp_path = Rails.root.join(".mcp.json")
         server_entry = {
@@ -36,46 +73,33 @@ module RailsAiContext
       end
 
       def create_initializer
+        tools_line = if @selected_formats.size == AI_TOOLS.size
+          "  # config.ai_tools = %i[claude cursor copilot windsurf opencode]  # default: all"
+        else
+          "  config.ai_tools = %i[#{@selected_formats.join(' ')}]"
+        end
+
         create_file "config/initializers/rails_ai_context.rb", <<~RUBY
           # frozen_string_literal: true
 
           RailsAiContext.configure do |config|
+            # AI tools to generate context files for (selected during install)
+            # Run `rails generate rails_ai_context:install` to change selection
+          #{tools_line}
+
             # Introspector preset:
-            #   :full     — all 28 introspectors (default — schema, models, routes, views, turbo, auth, API, assets, devops, etc.)
-            #   :standard — 13 core introspectors (schema, models, routes, jobs, gems, conventions, controllers, tests, migrations, stimulus, view_templates, design_tokens, config)
+            #   :full     — all 28 introspectors (default)
+            #   :standard — 13 core introspectors
             # config.preset = :full
 
-            # Or cherry-pick individual introspectors:
-            # config.introspectors += %i[views turbo auth api]
-
             # Models to exclude from introspection
             # config.excluded_models += %w[AdminUser InternalThing]
 
-            # Paths to exclude from code search
-            # config.excluded_paths += %w[vendor/bundle]
-
-            # Context mode for generated files (CLAUDE.md, .cursor/rules/, etc.)
-            # :compact — smart, ≤150 lines, references MCP tools for details (default)
-            # :full    — dumps everything into context files (good for small apps <30 models)
+            # Context mode: :compact (default, ≤150 lines) or :full (dumps everything)
             # config.context_mode = :compact
 
-            # Max lines for CLAUDE.md in compact mode
-            # config.claude_max_lines = 150
-
-            # Max response size for MCP tool results (chars). Safety net for large apps.
-            # config.max_tool_response_chars = 120_000
-
             # Live reload: auto-invalidate MCP tool caches on file changes
-            # :auto (default) — enable if `listen` gem is available
-            # true  — enable, raise if `listen` is missing
-            # false — disable entirely
             # config.live_reload = :auto
-            # config.live_reload_debounce = 1.5  # seconds
-
-            # Auto-mount HTTP MCP endpoint at /mcp
-            # config.auto_mount = false
-            # config.http_path  = "/mcp"
-            # config.http_port  = 6029
           end
         RUBY
 
@@ -104,13 +128,21 @@ module RailsAiContext
         say ""
         say "Generating AI context files...", :yellow
 
-        if Rails.application
-          require "rails_ai_context"
-          context = RailsAiContext.introspect
-          files = RailsAiContext.generate_context(format: :all)
-          files.each { |f| say "  Created #{f}", :green }
-        else
+        unless Rails.application
           say "  Skipped (Rails app not fully loaded). Run `rails ai:context` after install.", :yellow
+          return
+        end
+
+        require "rails_ai_context"
+
+        @selected_formats.each do |fmt|
+          begin
+            result = RailsAiContext.generate_context(format: fmt)
+            (result[:written] || []).each { |f| say "  ✅ #{f}", :green }
+            (result[:skipped] || []).each { |f| say "  ⏭️  #{f} (unchanged)", :yellow }
+          rescue => e
+            say "  ❌ #{fmt}: #{e.message}", :red
+          end
         end
       end
 
@@ -120,27 +152,26 @@ module RailsAiContext
         say " rails-ai-context installed!", :cyan
         say "=" * 50, :cyan
         say ""
-        say "Quick start:", :yellow
-        say "  rails ai:context         # Generate all context files"
-        say "  rails ai:context:claude   # Generate CLAUDE.md only"
-        say "  rails ai:context:cursor   # Generate .cursor/rules/ only"
-        say "  rails ai:serve           # Start MCP server (stdio)"
-        say "  rails ai:inspect         # Print introspection summary"
+        say "Your setup:", :yellow
+        AI_TOOLS.each_value do |info|
+          next unless @selected_formats.include?(info[:format])
+          say "  ✅ #{info[:name].ljust(16)} → #{info[:files]}"
+        end
         say ""
-        say "Generated files per AI tool:", :yellow
-        say "  Claude Code    → CLAUDE.md + .claude/rules/*.md"
-        say "  OpenCode       → AGENTS.md"
-        say "  Cursor         → .cursor/rules/*.mdc"
-        say "  Windsurf       → .windsurfrules + .windsurf/rules/*.md"
-        say "  GitHub Copilot → .github/copilot-instructions.md + .github/instructions/*.instructions.md"
+        say "Commands:", :yellow
+        say "  rails ai:context         # Regenerate context files"
+        say "  rails ai:serve           # Start MCP server (25 live tools)"
+        say "  rails ai:doctor          # Check AI readiness"
+        say "  rails ai:inspect         # Print introspection summary"
         say ""
         say "MCP auto-discovery:", :yellow
         say "  .mcp.json is auto-detected by Claude Code and Cursor."
-        say "  No manual MCP config needed — just open your project."
+        say "  No manual config needed — just open your project."
         say ""
-        say "Context modes:", :yellow
-        say "  rails ai:context         # compact mode (default, smart for any app size)"
-        say "  rails ai:context:full    # full dump (good for small apps)"
+        say "To add more AI tools later:", :yellow
+        say "  rails ai:context:cursor   # Generate for Cursor"
+        say "  rails ai:context:copilot  # Generate for Copilot"
+        say "  rails generate rails_ai_context:install  # Re-run to pick tools"
         say ""
         say "Commit context files and .mcp.json so your team benefits!", :green
       end

data/lib/rails_ai_context/configuration.rb

@@ -75,6 +75,10 @@ module RailsAiContext
     # Built-in tool names to skip (e.g. %w[rails_security_scan rails_get_design_system])
     attr_accessor :skip_tools
 
+    # Which AI tools to generate context for (selected during install)
+    # nil = all formats, or %i[claude cursor copilot windsurf opencode]
+    attr_accessor :ai_tools
+
     # Filtering — customize what's hidden from AI output
     attr_accessor :excluded_controllers   # Controller classes hidden from listings (e.g. DeviseController)
     attr_accessor :excluded_route_prefixes # Route controller prefixes hidden with app_only (e.g. action_mailbox/)
@@ -148,6 +152,7 @@ module RailsAiContext
       ]
       @custom_tools             = []
       @skip_tools               = []
+      @ai_tools                 = nil
       @search_extensions        = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
       @concern_paths            = %w[app/models/concerns app/controllers/concerns]
     end

data/lib/rails_ai_context/tasks/rails_ai_context.rake

@@ -24,24 +24,95 @@ def apply_context_mode_override
   end
 end unless defined?(apply_context_mode_override)
 
+AI_TOOL_OPTIONS = {
+  "1" => { key: :claude,   name: "Claude Code" },
+  "2" => { key: :cursor,   name: "Cursor" },
+  "3" => { key: :copilot,  name: "GitHub Copilot" },
+  "4" => { key: :windsurf, name: "Windsurf" },
+  "5" => { key: :opencode, name: "OpenCode" }
+}.freeze unless defined?(AI_TOOL_OPTIONS)
+
+def prompt_ai_tools
+  puts ""
+  puts "Which AI tools do you use? (select all that apply)"
+  puts ""
+  AI_TOOL_OPTIONS.each { |num, info| puts "  #{num}. #{info[:name]}" }
+  puts "  a. All of the above"
+  puts ""
+  print "Enter numbers separated by commas (e.g. 1,2) or 'a' for all: "
+  input = $stdin.gets&.strip&.downcase || "a"
+
+  selected = if input == "a" || input == "all" || input.empty?
+    AI_TOOL_OPTIONS.values.map { |t| t[:key] }
+  else
+    input.split(/[\s,]+/).filter_map { |n| AI_TOOL_OPTIONS[n]&.dig(:key) }
+  end
+
+  if selected.empty?
+    puts "No tools selected — using all."
+    selected = AI_TOOL_OPTIONS.values.map { |t| t[:key] }
+  end
+
+  names = AI_TOOL_OPTIONS.values.select { |t| selected.include?(t[:key]) }.map { |t| t[:name] }
+  puts "Selected: #{names.join(', ')}"
+  selected
+end unless defined?(prompt_ai_tools)
+
+def save_ai_tools_to_initializer(tools)
+  init_path = Rails.root.join("config/initializers/rails_ai_context.rb")
+  return unless File.exist?(init_path)
+
+  content = File.read(init_path)
+  tools_line = "  config.ai_tools = %i[#{tools.join(' ')}]"
+
+  if content.include?("config.ai_tools")
+    # Replace existing ai_tools line
+    content.sub!(/^.*config\.ai_tools.*$/, tools_line)
+  elsif content.include?("RailsAiContext.configure")
+    # Insert after configure block opening
+    content.sub!(/RailsAiContext\.configure do \|config\|\n/, "RailsAiContext.configure do |config|\n#{tools_line}\n")
+  else
+    return
+  end
+
+  File.write(init_path, content)
+  puts "💾 Saved to config/initializers/rails_ai_context.rb"
+rescue
+  nil
+end unless defined?(save_ai_tools_to_initializer)
+
 namespace :ai do
-  desc "Generate AI context files (CLAUDE.md, .cursor/rules/, .windsurfrules, .github/copilot-instructions.md)"
+  desc "Generate AI context files for configured AI tools (prompts on first run)"
   task context: :environment do
     require "rails_ai_context"
 
     apply_context_mode_override
 
+    ai_tools = RailsAiContext.configuration.ai_tools
+
+    # First time — no tools configured, ask the user
+    if ai_tools.nil?
+      ai_tools = prompt_ai_tools
+      save_ai_tools_to_initializer(ai_tools) if ai_tools
+    end
+
     puts "🔍 Introspecting #{Rails.application.class.module_parent_name}..."
 
-    puts "📝 Writing context files..."
-    result = RailsAiContext.generate_context(format: :all)
+    if ai_tools.nil? || ai_tools.empty?
+      puts "📝 Writing context files for all AI tools..."
+      result = RailsAiContext.generate_context(format: :all)
+      print_result(result)
+    else
+      puts "📝 Writing context files for: #{ai_tools.map(&:to_s).join(', ')}..."
+      ai_tools.each do |fmt|
+        result = RailsAiContext.generate_context(format: fmt)
+        print_result(result)
+      end
+    end
 
-    print_result(result)
     puts ""
-    puts "Done! Your AI assistants now understand your Rails app."
-    puts "Commit these files so your whole team benefits."
-    puts ""
-    puts ASSISTANT_TABLE
+    puts "Done! Commit these files so your team benefits."
+    puts "Change AI tools: config/initializers/rails_ai_context.rb (config.ai_tools)"
   end
 
   desc "Generate AI context in a specific format (claude, cursor, windsurf, copilot, json)"

data/lib/rails_ai_context/tools/get_routes.rb

@@ -168,7 +168,19 @@ module RailsAiContext
                   ctrl_lines << "- `#{r[:verb]}` `#{r[:path]}` → #{r[:action]}#{helper_part}#{params_part}"
                 end
                 if ctrl_lines.any?
-                  lines << "## #{ctrl}"
+                  # Inline controller summary so AI doesn't need a separate get_controllers call
+                  ctrl_class = "#{ctrl.camelize}Controller"
+                  ctrl_data = cached_context.dig(:controllers, :controllers, ctrl_class)
+                  ctrl_summary = ""
+                  if ctrl_data
+                    filters = (ctrl_data[:filters] || []).map { |f| f[:name] }.first(3)
+                    formats = ctrl_data[:respond_to_formats]
+                    parts = []
+                    parts << "filters: #{filters.join(', ')}" if filters.any?
+                    parts << "formats: #{formats.join(', ')}" if formats&.any?
+                    ctrl_summary = " (#{parts.join(' | ')})" if parts.any?
+                  end
+                  lines << "## #{ctrl}#{ctrl_summary}"
                   lines.concat(ctrl_lines)
                   lines << ""
                 end

data/lib/rails_ai_context/tools/get_schema.rb

@@ -144,7 +144,19 @@ module RailsAiContext
                 hint_str = hints.any? ? " [#{hints.join(', ')}]" : ""
                 "#{c[:name]}:#{c[:type]}#{hint_str}"
               end.join(", ")
-            lines << "### #{name}"
+            # Inline model info so AI doesn't need a separate get_model_details call
+            model_info = ""
+            if model_refs.any?
+              model_refs.each do |mname|
+                md = models_data[mname]
+                next unless md.is_a?(Hash) && !md[:error]
+                assoc_count = md[:associations]&.size || 0
+                val_count = md[:validations]&.size || 0
+                model_info = " → **#{mname}** (#{assoc_count} assoc, #{val_count} val)"
+                break
+              end
+            end
+            lines << "### #{name}#{model_info}"
             lines << cols
             lines << ""
           end

data/lib/rails_ai_context/tools/get_test_info.rb

@@ -76,6 +76,11 @@ module RailsAiContext
             lines << "" << "## Test Helpers"
             data[:test_helpers].each { |h| lines << "- `#{h}`" }
           end
+
+          # Generate a test template based on app patterns
+          template = generate_test_template(data)
+          lines.concat(template) if template.any?
+
           text_response(lines.join("\n"))
 
         when "full"
@@ -210,6 +215,89 @@ module RailsAiContext
         "No test file found for #{name}. Searched: #{candidates.join(', ')}#{hint}"
       end
 
+      # Generate a test template based on the app's actual test patterns
+      private_class_method def self.generate_test_template(data)
+        lines = []
+        framework = data[:framework]
+
+        if framework&.include?("RSpec") || framework&.include?("rspec")
+          lines << "" << "## Test Template (follow this pattern for new tests)"
+          lines << "```ruby"
+          lines << "require \"rails_helper\""
+          lines << ""
+          lines << "RSpec.describe ModelName, type: :model do"
+          lines << "  describe \"validations\" do"
+          lines << "    it { is_expected.to validate_presence_of(:field) }"
+          lines << "  end"
+          lines << ""
+          lines << "  describe \"#method_name\" do"
+          lines << "    it \"does something\" do"
+          lines << "      record = create(:model_name)"
+          lines << "      expect(record.method_name).to eq(expected)"
+          lines << "    end"
+          lines << "  end"
+          lines << "end"
+          lines << "```"
+        else
+          # Detect Devise + sign_in pattern from existing tests
+          has_devise = false
+          has_sign_in = false
+          test_dir = Rails.root.join("test")
+          if Dir.exist?(test_dir)
+            Dir.glob(File.join(test_dir, "**/*_test.rb")).first(5).each do |path|
+              content = File.read(path, encoding: "UTF-8") rescue next
+              has_devise = true if content.include?("Devise::Test")
+              has_sign_in = true if content.include?("sign_in")
+            end
+          end
+
+          lines << "" << "## Test Template (follow this pattern for new tests)"
+          lines << "```ruby"
+          lines << "require \"test_helper\""
+          lines << ""
+          lines << "class ModelNameTest < ActiveSupport::TestCase"
+          lines << "  test \"should be valid with required attributes\" do"
+          lines << "    record = model_names(:fixture_name)"
+          lines << "    assert record.valid?"
+          lines << "  end"
+          lines << ""
+          lines << "  test \"should require field\" do"
+          lines << "    record = ModelName.new"
+          lines << "    assert_not record.valid?"
+          lines << "    assert_includes record.errors[:field], \"can't be blank\""
+          lines << "  end"
+          lines << "end"
+          lines << "```"
+
+          if has_devise
+            lines << ""
+            lines << "```ruby"
+            lines << "# Controller test pattern"
+            lines << "require \"test_helper\""
+            lines << ""
+            lines << "class FeatureControllerTest < ActionDispatch::IntegrationTest"
+            lines << "  include Devise::Test::IntegrationHelpers" if has_devise
+            lines << ""
+            lines << "  test \"requires authentication\" do"
+            lines << "    get feature_path"
+            lines << "    assert_response :redirect"
+            lines << "  end"
+            lines << ""
+            lines << "  test \"shows page for signed in user\" do"
+            lines << "    sign_in users(:chef_one)" if has_sign_in
+            lines << "    get feature_path"
+            lines << "    assert_response :success"
+            lines << "  end"
+            lines << "end"
+            lines << "```"
+          end
+        end
+
+        lines
+      rescue
+        []
+      end
+
       # Parse factory file to extract attributes and traits
       private_class_method def self.parse_factory_details(relative_path)
         # Try common factory locations

data/lib/rails_ai_context/tools/get_view.rb

@@ -96,12 +96,14 @@ module RailsAiContext
 
             lines << "## #{ctrl}/" unless controller && all_dirs.size == 1
             ctrl_templates.sort.each do |name, meta|
-              parts = meta[:partials]&.any? ? " renders: #{meta[:partials].join(', ')}" : ""
-              stim = meta[:stimulus]&.any? ? " stimulus: #{meta[:stimulus].join(', ')}" : ""
+              detail_parts = []
+              detail_parts << "renders: #{meta[:partials].join(', ')}" if meta[:partials]&.any?
+              detail_parts << "stimulus: #{meta[:stimulus].join(', ')}" if meta[:stimulus]&.any?
               extra = extract_view_metadata(name)
-              ivars = extra[:ivars]&.any? ? " ivars: #{extra[:ivars].join(', ')}" : ""
-              turbo = extra[:turbo]&.any? ? " turbo: #{extra[:turbo].join(', ')}" : ""
-              lines << "- #{name} (#{meta[:lines]} lines)#{parts}#{stim}#{ivars}#{turbo}"
+              detail_parts << "ivars: #{extra[:ivars].join(', ')}" if extra[:ivars]&.any?
+              detail_parts << "turbo: #{extra[:turbo].join(', ')}" if extra[:turbo]&.any?
+              details = detail_parts.any? ? " — #{detail_parts.join(' | ')}" : ""
+              lines << "- **#{name}** (#{meta[:lines]} lines)#{details}"
             end
             ctrl_partials.sort.each do |name, meta|
               fields = meta[:fields]&.any? ? " fields: #{meta[:fields].join(', ')}" : ""