rails-ai-context 2.0.0 → 2.0.2

data/lib/rails_ai_context/tools/search_code.rb

@@ -6,24 +6,15 @@ module RailsAiContext
   module Tools
     class SearchCode < BaseTool
       tool_name "rails_search_code"
-      description "Search the Rails codebase by regex pattern, returning matching lines with file paths and line numbers. " \
-        "Use when: finding where a method is called, locating class definitions, or tracing how a feature is implemented. " \
-        "Requires pattern:\"def activate\". Narrow with path:\"app/models\" and file_type:\"rb\"."
+      description "Search the Rails codebase with smart modes. " \
+        "Use match_type:\"trace\" to see where a method is defined, who calls it, and what it calls — in one call. " \
+        "Use match_type:\"definition\" for definitions only, \"call\" for call sites only, \"class\" for class/module definitions. " \
+        "Requires pattern:\"method_name\". Narrow with path:\"app/models\" and file_type:\"rb\"."
 
       def self.max_results_cap
         RailsAiContext.configuration.max_search_results
       end
 
-      # Non-code files excluded from all searches — lock files, docs, generated context, config meta
-      NON_CODE_GLOBS = %w[
-        *.lock package-lock.json yarn.lock pnpm-lock.yaml bun.lockb
-        *.md LICENSE* CHANGELOG* CONTRIBUTING*
-        CLAUDE.md AGENTS.md .cursorrules .cursor/ .claude/
-        Dockerfile* docker-compose*
-        .rubocop.yml .ruby-version .node-version .tool-versions
-        .github/ .circleci/ .gitlab-ci.yml
-      ].freeze
-
       input_schema(
         properties: {
           pattern: {
@@ -40,16 +31,24 @@ module RailsAiContext
           },
           match_type: {
             type: "string",
-            enum: %w[any definition class],
-            description: "Filter match type. any: all matches (default). definition: only `def method_name` lines. class: only `class/module Name` lines."
+            enum: %w[any definition class call trace],
+            description: "any: all matches (default). definition: `def` lines only. class: `class/module` lines. call: call sites only (excludes definitions). trace: FULL PICTURE — shows definition + source code + all callers + what it calls internally."
           },
           exact_match: {
             type: "boolean",
             description: "Match whole words only (wraps pattern in \\b word boundaries). Default: false."
           },
-          max_results: {
+          exclude_tests: {
+            type: "boolean",
+            description: "Exclude test/spec files from results. Default: false."
+          },
+          group_by_file: {
+            type: "boolean",
+            description: "Group results by file with match counts. Default: false."
+          },
+          offset: {
             type: "integer",
-            description: "Maximum number of results. Default: 30, max: 200."
+            description: "Skip this many results for pagination. Default: 0."
           },
           context_lines: {
             type: "integer",
@@ -61,31 +60,40 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
-      def self.call(pattern:, path: nil, file_type: nil, match_type: "any", exact_match: false, max_results: 30, context_lines: 2, server_context: nil)
+      def self.call(pattern:, path: nil, file_type: nil, match_type: "any", exact_match: false, exclude_tests: false, group_by_file: false, offset: 0, context_lines: 2, server_context: nil) # rubocop:disable Metrics
         root = Rails.root.to_s
+        original_pattern = pattern
 
         # Reject empty or whitespace-only patterns
         if pattern.nil? || pattern.strip.empty?
           return text_response("Pattern is required. Provide a search term or regex.")
         end
 
+        # Trace mode — the game changer: full method picture in one call
+        if match_type == "trace"
+          return trace_method(pattern.strip, root, path, exclude_tests)
+        end
+
         # Apply exact_match word boundaries
         pattern = "\\b#{pattern}\\b" if exact_match
 
-        # Apply match_type filter to pattern (strip keyword if user already included it)
-        pattern = case match_type
+        # Apply match_type filter to pattern
+        search_pattern = case match_type
         when "definition"
           cleaned = pattern.sub(/\A\s*def\s+/, "")
           "^\\s*def\\s+(self\\.)?#{cleaned}"
         when "class"
           cleaned = pattern.sub(/\A\s*(class|module)\s+/, "")
-          "^\\s*(class|module)\\s+#{cleaned}"
-        else pattern
+          "^\\s*(class|module)\\s+\\w*#{cleaned}"
+        when "call"
+          pattern
+        else
+          pattern
         end
 
         # Validate regex syntax early
         begin
-          Regexp.new(pattern, timeout: 1)
+          Regexp.new(search_pattern, timeout: 1)
         rescue RegexpError => e
           return text_response("Invalid regex pattern: #{e.message}")
         end
@@ -95,10 +103,8 @@ module RailsAiContext
           return text_response("Invalid file_type: must contain only alphanumeric characters.")
         end
 
-        # Cap max_results and context_lines
-        max_results = [ max_results.to_i, max_results_cap ].min
-        max_results = 30 if max_results < 1
         context_lines = [ [ context_lines.to_i, 0 ].max, 5 ].min
+        offset = [ offset.to_i, 0 ].max
 
         search_path = path ? File.join(root, path) : root
 
@@ -118,28 +124,60 @@ module RailsAiContext
           return text_response("Path not found: #{path}")
         end
 
-        results = if ripgrep_available?
-                    search_with_ripgrep(pattern, search_path, file_type, max_results, root, context_lines)
+        # Fetch all results (capped at 200 for safety)
+        all_results = if ripgrep_available?
+          search_with_ripgrep(search_pattern, search_path, file_type, max_results_cap, root, context_lines, exclude_tests: exclude_tests)
         else
-                    search_with_ruby(pattern, search_path, file_type, max_results, root)
+          search_with_ruby(search_pattern, search_path, file_type, max_results_cap, root, exclude_tests: exclude_tests)
+        end
+
+        # Filter out definitions for match_type:"call"
+        all_results.reject! { |r| r[:content].match?(/\A\s*def\s/) } if match_type == "call"
+
+        if all_results.empty?
+          return text_response("No results found for '#{original_pattern}' in #{path || 'app'}.")
         end
 
-        if results.empty?
-          return text_response("No results found for '#{pattern}' in #{path || 'app'}.")
+        # Smart result limiting:
+        # <10 total → show all, 10-100 → show half, >100 → cap at 100
+        total = all_results.size
+        show_count = if total <= 10 then total
+        elsif total <= 100 then (total / 2.0).ceil
+        else 100
         end
 
-        output = results.map { |r| "#{r[:file]}:#{r[:line_number]}: #{r[:content].strip}" }.join("\n")
-        header = "# Search: `#{pattern}`\n**#{results.size} results**#{" in #{path}" if path}\n\n```\n"
-        footer = "\n```"
+        # Apply pagination
+        paginated = all_results.drop(offset).first(show_count)
 
-        text_response("#{header}#{output}#{footer}")
+        if paginated.empty? && total > 0
+          return text_response("No results at offset #{offset}. Total: #{total}. Use `offset:0`.")
+        end
+
+        # Build header with total count and pagination info
+        showing = offset > 0 ? "#{offset + 1}-#{offset + paginated.size}" : "#{paginated.size}"
+        pagination = if offset + paginated.size < total
+          "\n_Showing #{showing} of #{total}. Use `offset:#{offset + paginated.size}` for more._"
+        elsif total > paginated.size
+          "\n_Showing #{showing} of #{total}._"
+        else
+          ""
+        end
+
+        header = "# Search: `#{original_pattern}`\n**#{total} total results**#{" in #{path}" if path}, showing #{showing}\n"
+
+        if group_by_file
+          text_response(header + "\n" + format_grouped(paginated) + pagination)
+        else
+          output = paginated.map { |r| "#{r[:file]}:#{r[:line_number]}: #{r[:content].strip}" }.join("\n")
+          text_response("#{header}\n```\n#{output}\n```#{pagination}")
+        end
       end
 
       private_class_method def self.ripgrep_available?
         @rg_available ||= system("which rg > /dev/null 2>&1")
       end
 
-      private_class_method def self.search_with_ripgrep(pattern, search_path, file_type, max_results, root, ctx_lines = 0)
+      private_class_method def self.search_with_ripgrep(pattern, search_path, file_type, max_results, root, ctx_lines = 0, exclude_tests: false)
         cmd = [ "rg", "--no-heading", "--line-number", "--sort=path", "--max-count", max_results.to_s ]
         if ctx_lines > 0
           cmd.push("-C", ctx_lines.to_s)
@@ -157,9 +195,12 @@ module RailsAiContext
           cmd << "--glob=!#{p}"
         end
 
-        # Exclude non-code files that generate noise in search results
-        # (excluded_paths already handles node_modules, tmp, log, vendor, .git)
-        NON_CODE_GLOBS.each { |glob| cmd << "--glob=!#{glob}" }
+        # Exclude test/spec directories if requested
+        if exclude_tests
+          cmd << "--glob=!test/"
+          cmd << "--glob=!spec/"
+          cmd << "--glob=!features/"
+        end
 
         if file_type
           cmd.push("--type-add", "custom:*.#{file_type}", "--type", "custom")
@@ -178,7 +219,7 @@ module RailsAiContext
         [ { file: "error", line_number: 0, content: e.message } ]
       end
 
-      private_class_method def self.search_with_ruby(pattern, search_path, file_type, max_results, root)
+      private_class_method def self.search_with_ruby(pattern, search_path, file_type, max_results, root, exclude_tests: false)
         results = []
         begin
           regex = Regexp.new(pattern, Regexp::IGNORECASE, timeout: 2)
@@ -189,11 +230,13 @@ module RailsAiContext
         glob = file_type ? "**/*.#{file_type}" : "**/*.{#{extensions}}"
         excluded = RailsAiContext.configuration.excluded_paths
         sensitive = RailsAiContext.configuration.sensitive_patterns
+        test_dirs = %w[test/ spec/ features/]
 
         Dir.glob(File.join(search_path, glob)).each do |file|
           relative = file.sub("#{root}/", "")
           next if excluded.any? { |ex| relative.start_with?(ex) }
           next if sensitive_file?(relative, sensitive)
+          next if exclude_tests && test_dirs.any? { |td| relative.start_with?(td) }
 
           File.readlines(file).each_with_index do |line, idx|
             if line.match?(regex)
@@ -216,6 +259,20 @@ module RailsAiContext
         end
       end
 
+      # Group results by file for cleaner output
+      private_class_method def self.format_grouped(results)
+        grouped = results.group_by { |r| r[:file] }
+        lines = []
+        grouped.each do |file, matches|
+          lines << "## #{file} (#{matches.size} matches)"
+          lines << "```"
+          matches.each { |r| lines << "#{r[:line_number]}: #{r[:content].strip}" }
+          lines << "```"
+          lines << ""
+        end
+        lines.join("\n")
+      end
+
       private_class_method def self.parse_rg_output(output, root)
         output.lines.filter_map do |line|
           next if line.strip == "--" # Skip group separators from -C context output
@@ -229,6 +286,129 @@ module RailsAiContext
           }
         end
       end
+
+      # ── Trace Mode — the game changer ──────────────────────────────
+      # Shows definition + source + callers + internal calls in one response
+
+      private_class_method def self.trace_method(method_name, root, path, exclude_tests) # rubocop:disable Metrics
+        # Clean input: strip "def ", "self.", parens
+        cleaned = method_name.sub(/\A\s*def\s+/, "").sub(/\Aself\./, "").sub(/\(.*/, "").strip
+        return text_response("Provide a method name to trace.") if cleaned.empty?
+
+        search_path = path ? File.join(root, path) : root
+        lines = [ "# Trace: `#{cleaned}`", "" ]
+
+        # 1. Find the definition (no \b after ? or ! since they ARE word boundaries)
+        def_pattern = "^\\s*def\\s+(self\\.)?#{Regexp.escape(cleaned)}"
+        def_pattern += "\\b" unless cleaned.end_with?("?") || cleaned.end_with?("!")
+        def_results = quick_search(def_pattern, search_path, root, 10, exclude_tests)
+
+        if def_results.any?
+          lines << "## Definition"
+          def_results.each do |r|
+            lines << "**#{r[:file]}:#{r[:line_number]}**"
+            # Extract the full method body
+            body = extract_method_body(File.join(root, r[:file]), r[:line_number])
+            if body
+              lines << "```ruby"
+              lines << body
+              lines << "```"
+
+              # 3. What does this method call? (extract method-like calls from body)
+              internal_calls = body.scan(/\b([a-z_]\w*[!?]?)(?:\s*[\(])/).flatten.uniq
+              internal_calls += body.scan(/\b([A-Z]\w+(?:::\w+)*)\.(new|call|perform_later|perform_async|find|where|create)/).map { |c| "#{c[0]}.#{c[1]}" }
+              internal_calls.reject! { |c| %w[if else elsif unless return end def class module do begin rescue ensure raise puts print].include?(c) }
+              internal_calls.reject! { |c| c == cleaned }
+
+              if internal_calls.any?
+                lines << "" << "## Calls internally"
+                internal_calls.first(15).each { |c| lines << "- `#{c}`" }
+              end
+            end
+            lines << ""
+          end
+        else
+          lines << "_No definition found for `def #{cleaned}`_"
+          lines << ""
+        end
+
+        # 2. Find all callers (everywhere the method is referenced, excluding the def line)
+        call_pattern = if cleaned.end_with?("?") || cleaned.end_with?("!")
+          "#{Regexp.escape(cleaned)}"
+        else
+          "\\b#{Regexp.escape(cleaned)}\\b"
+        end
+        call_results = quick_search(call_pattern, search_path, root, max_results_cap, exclude_tests)
+        callers = call_results.reject { |r| r[:content].match?(/\A\s*def\s/) }
+
+        # Exclude the definition file+line to avoid self-reference
+        def_locations = def_results.map { |r| "#{r[:file]}:#{r[:line_number]}" }.to_set
+        callers.reject! { |r| def_locations.include?("#{r[:file]}:#{r[:line_number]}") }
+
+        if callers.any?
+          lines << "## Called from (#{callers.size} sites)"
+
+          # Group by file for readability
+          grouped = callers.group_by { |r| r[:file] }
+          grouped.each do |file, matches|
+            # Categorize the file
+            category = case file
+            when /controller/i then "Controller"
+            when /model/i then "Model"
+            when /view|\.erb/i then "View"
+            when /job/i then "Job"
+            when /service/i then "Service"
+            when /test|spec/i then "Test"
+            when /\.js$|\.ts$/i then "JavaScript"
+            else "Other"
+            end
+
+            lines << "### #{file} (#{category})"
+            matches.first(5).each do |r|
+              lines << "  #{r[:line_number]}: #{r[:content].strip}"
+            end
+            lines << "  _(#{matches.size - 5} more)_" if matches.size > 5
+          end
+        else
+          lines << "## Called from"
+          lines << "_No call sites found (method may be unused or called dynamically)_"
+        end
+
+        text_response(lines.join("\n"))
+      rescue => e
+        text_response("Trace error: #{e.message}")
+      end
+
+      # Fast ripgrep search for trace mode (no formatting, just results)
+      private_class_method def self.quick_search(pattern, search_path, root, limit, exclude_tests)
+        if ripgrep_available?
+          search_with_ripgrep(pattern, search_path, nil, limit, root, 0, exclude_tests: exclude_tests)
+        else
+          search_with_ruby(pattern, search_path, nil, limit, root, exclude_tests: exclude_tests)
+        end
+      end
+
+      # Extract a method body from a file given the def line number
+      private_class_method def self.extract_method_body(file_path, def_line)
+        return nil unless File.exist?(file_path)
+        return nil if File.size(file_path) > RailsAiContext.configuration.max_file_size
+
+        source_lines = File.readlines(file_path)
+        start_idx = def_line - 1
+        return nil if start_idx >= source_lines.size
+
+        def_indent = source_lines[start_idx][/\A\s*/].length
+        result = [ source_lines[start_idx].rstrip ]
+
+        source_lines[(start_idx + 1)..].each do |line|
+          result << line.rstrip
+          break if line.match?(/\A\s{#{def_indent}}end\b/)
+        end
+
+        result.join("\n")
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/rails_ai_context/tools/validate.rb

@@ -95,6 +95,12 @@ module RailsAiContext
           end
         end
 
+        # Run Brakeman security scan on validated files (if installed and level:"rails")
+        if level == "rails"
+          brakeman_warnings = check_brakeman_security(files)
+          brakeman_warnings.each { |w| results << "  \u26A0 #{w}" }
+        end
+
         output = results.join("\n")
         output += "\n\n#{passed}/#{total} files passed"
         output += " _(Prism unavailable — using fallback parser, some semantic checks skipped)_" unless prism_available?
@@ -950,6 +956,48 @@ module RailsAiContext
       rescue
         []
       end
+
+      # ── Brakeman security scan (runs once for all files) ───────────
+
+      private_class_method def self.check_brakeman_security(files)
+        return [] unless brakeman_available?
+
+        tracker = Brakeman.run(
+          app_path: Rails.root.to_s,
+          quiet: true,
+          report_progress: false,
+          print_report: false
+        )
+
+        warnings = tracker.filtered_warnings
+        return [] if warnings.empty?
+
+        # Filter to only warnings in the validated files
+        normalized = files.map { |f| f.delete_prefix("/") }
+        relevant = warnings.select do |w|
+          path = w.file.relative
+          normalized.any? { |f| path == f || path.start_with?(f) }
+        end
+        return [] if relevant.empty?
+
+        relevant.sort_by(&:confidence).first(5).map do |w|
+          loc = w.line ? "#{w.file.relative}:#{w.line}" : w.file.relative
+          "[#{w.confidence_name}] #{w.warning_type} — #{loc}: #{w.message}"
+        end
+      rescue
+        []
+      end
+
+      private_class_method def self.brakeman_available?
+        return @brakeman_available unless @brakeman_available.nil?
+
+        @brakeman_available = begin
+          require "brakeman"
+          true
+        rescue LoadError
+          false
+        end
+      end
     end
   end
 end

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "2.0.0"
+  VERSION = "2.0.2"
 end

data/server.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "2.0.0",
+  "version": "2.0.2",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v2.0.0/rails-ai-context-mcp.mcpb",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v2.0.2/rails-ai-context-mcp.mcpb",
       "fileSha256": "dd711a0ad6c4de943ae4da94eaf59a6dc9494b9d57f726e24649ed4e2f156990",
       "transport": {
         "type": "stdio"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - crisnahine