rails-ai-context 5.36.4 → 5.36.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0dd31bd07cbfa7f5cb1e1232627cda1c7ea16f035f864d8db86e1f544bb3893
-  data.tar.gz: 92512c007d7fc751a59bf72b1f651fb2a6e58117bc47697e109c145cbd65b6cf
+  metadata.gz: d19c2da6b45c1d8622c9d97bf31f005a10a904c1c6361c9f2d4d75819bdb236d
+  data.tar.gz: cdc5979f3619e5823f7a3b158864e4c0fe1b2e62037074925334dcfbef50ce2b
 SHA512:
-  metadata.gz: 0d751847ce7745680c03f69a54077e1f8a1836c37e788d78ad5072792af68be4f7e531b98e5bc3b62159e8b297259d8ebc2649ee22c41b6150edc90e9faf0c69
-  data.tar.gz: a64566fdec0abb014195d48dcf81d2463a24b9c72addaec1254dcac0778e6f4190805baddfdf073ec2ca5b847fe4ebc4ba643de759b46fc5a16e13b586e80dab
+  metadata.gz: bd790f4fe94ffd61064e3d65d62335de351af8c7d90669370c4b42c6cb37b1284dbf62c6ca3160d1ac7ee801dbf378c40764b361f6903197716823849246d238
+  data.tar.gz: '083dcf1bdcbe006da36854877cae12ae6bdea0282f8411686609e85b4fd029adf62f430f3c5780c78f624059757b46ec58bb188d48a017a7e9451e1ee3253bb4'

data/CHANGELOG.md

@@ -5,6 +5,62 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.36.5] - 2026-10-19
+
+### Added
+
+- **`rails_get_edit_context` takes a `line`.** It shows `context_lines` either
+  side of that line, so a line from a stack trace needs no text to search for.
+  `near` is needed only without one.
+
+### Fixed
+
+- **`rails_diagnose` shows the code around the line it was given** (#495). It
+  searched for the method name and opened on its first mention, a comment
+  included, so the failing line was missing from the code shown in 18 of 30
+  real calls on one app. It also reads a setter's name (`title=`) and an index
+  call's (`[]`), and names their nil receiver.
+- **`rails_migration_advisor` points a foreign key at the key of a table not
+  keyed by `id`** (#496): `foreign_key: { primary_key: :bid }`, where
+  `foreign_key: true` made PostgreSQL refuse the migration. A table with a
+  composite primary key, and a `t.references` table the schema lacks, get no
+  foreign key and a line saying why.
+- **`rails_migration_advisor` types a reference the way the key it points at
+  is typed** (#501). A reference to an `integer` key gets `type: :integer`
+  and the key's `limit:` when it has one, and on MySQL one to an `unsigned`
+  key gets `unsigned: true`. It wrote Rails' default signed bigint, and MySQL
+  and MariaDB refuse a foreign key whose column differs from the key, so the
+  migration failed. PostgreSQL, which accepted the bigint, now gets the
+  matching type too. A `serial` key gives `integer` and a `smallserial` one
+  `smallint`, where the reference used to get a sequence of its own that
+  filled it with a made-up owner. SQLite, where every key is an integer,
+  still gets no type.
+- **`rails_analyze_feature` lists every service, view and spec whose name
+  matches** (#497), wherever it sorts. Only the files it reads stop at 500 per
+  directory, and the closing note says which directory past them was matched
+  by name alone. The test gap list reads the name of every test, so it is no
+  longer left out on a suite of more than 500.
+- **`conventions` counts the TypeScript, JSX and Vue files of `app/javascript`**
+  (#498), and the `.ruby` templates of `app/views`. Mastodon's `app/javascript`
+  read 78 files; it holds 922. An edit to one of those files, or to a
+  `.jbuilder` or `.builder` view, now refreshes the cached answers, as one to a
+  `.js` or `.erb` file did.
+- **`rails_migration_advisor`'s Strong Migrations warning for `add_association`
+  rewrites the `add_reference` it wrote** (#499). It named the reference as the
+  table (`add_foreign_key :listings, :owner`) and added a second key after the
+  migration had added one. On PostgreSQL it now gives the reference with
+  `disable_ddl_transaction!` and a concurrent index, the key in its own
+  `add_foreign_key ... validate: false` (strong_migrations before 2.5.2 flags any
+  foreign key inside `add_reference`), then `validate_foreign_key` with
+  the real table and column. On MySQL it moves the key to a separate
+  migration, as strong_migrations 2.7 and later require; an older locked version,
+  which does not check a MySQL key, gets no warning. A reference with no
+  foreign key gets only the concurrent index on PostgreSQL and nothing on
+  MySQL, and SQLite, which strong_migrations does not check, gets nothing. A
+  reference whose column already exists gets no warning, since its migration
+  fails first, and an undecided database gets one line when the reference has
+  a key.
+
 ## [5.36.4] - 2026-10-16
 
 ### Added

data/docs/COMPATIBILITY.md

@@ -346,6 +346,14 @@ Proof sources:
    static tier, with the app's pinned json and net-http still loaded; the
    suite on prism 1.4.0 and on prism main under Ruby 3.2 and 3.4; and the unit
    suite and the E2E harness on Linux, macOS and Windows.
+   In the v5.36.5 release QA: each fix's example failing on the code before
+   it; the advice `rails_migration_advisor` writes run as real migrations
+   under strong_migrations 1.8 to 2.8 and Active Record 7.0 to 8.1 against
+   PostgreSQL 13, 16 and 17, MySQL 8.0 and 8.4, MariaDB 10.6 and 11.4 and
+   SQLite, for bigint, integer, unsigned, serial and uuid keys; its answers on
+   three corpus apps in the static tier; the unit suite on Ruby 3.1 to 4.0
+   with Rails 7.0 to 8.1 on macOS, with seeds 1, 27377 and 90210 and defined
+   order; and the unit suite and the E2E harness on Linux, macOS and Windows.
 2. Non-crash coverage for every built-in tool including `get_view` in
    `spec/e2e/in_gemfile_install_spec.rb`'s full-tool sweep; output correctness
    (ivar cross-check, render-form detection, partial interfaces) verified

data/docs/GUIDE.md

@@ -700,8 +700,9 @@ Returns just enough context to make a surgical Edit to a file. Returns the targe
 | Param | Type | Description |
 |-------|------|-------------|
 | `file` | string | **Required.** File path relative to Rails root (e.g. `app/models/post.rb`). |
-| `near` | string | **Required.** What to find - a method name, keyword, or string to locate (e.g. `scope`, `def index`). |
+| `near` | string | **Required** unless `line` is given. What to find - a method name, keyword, or string to locate (e.g. `scope`, `def index`). |
 | `context_lines` | integer | Lines of context above and below the match. Default: 5. |
+| `line` | integer | Show `context_lines` either side of this line number instead of searching for `near`. |
 
 **Examples:**
 

data/docs/TOOLS.md

@@ -104,8 +104,9 @@ Method-aware code extraction with surrounding class context. Every line returned
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
 | `file` | string | *required* | File path relative to Rails root |
-| `near` | string | *required* | What to find in the file: a method name, keyword or string (e.g. `def index`, `validates`, `STATUSES`) |
+| `near` | string | *required* unless `line` | What to find in the file: a method name, keyword or string (e.g. `def index`, `validates`, `STATUSES`) |
 | `context_lines` | integer | `5` | Lines of context above and below the match |
+| `line` | integer | - | Show `context_lines` either side of this line instead of searching for `near`; past the end of the file, `near` is searched for |
 
 <p align="right"><a href="#table-of-contents">↑ back to top</a></p>
 

data/lib/rails_ai_context/fingerprinter.rb

@@ -50,7 +50,7 @@ module RailsAiContext
     # a change and a walk that names it read the same tree.
     # sql: a structure dump, under whatever name database.yml's schema_dump gives it.
     # tt: a generator template override under lib/templates.
-    WATCHED_EXTNAMES = %w[.rb .rake .js .ts .erb .haml .slim .yml .sql .tt].freeze
+    WATCHED_EXTNAMES = %w[.rb .rake .js .jsx .mjs .cjs .ts .tsx .vue .svelte .erb .haml .slim .jbuilder .builder .ruby .yml .sql .tt].freeze
     WATCHED_EXTENSIONS = "**/*{#{WATCHED_EXTNAMES.join(",")}}"
 
     # jsbundling and cssbundling rewrite this on every frontend save, and no reader reads it.

data/lib/rails_ai_context/introspectors/convention_introspector.rb

@@ -172,11 +172,12 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, false, label: "uses_async_queries?")
       end
 
+      SCRIPT_FILES = "**/*.{js,jsx,mjs,cjs,ts,tsx,vue,svelte}"
       # Files a directory holds besides Ruby, which SourceScan leaves out.
       NON_RUBY_FILES = {
-        "app/javascript" => "**/*.js",
-        "app/javascript/controllers" => "**/*.js",
-        "app/views" => "**/*.{erb,haml,slim,jbuilder,builder}",
+        "app/javascript" => SCRIPT_FILES,
+        "app/javascript/controllers" => SCRIPT_FILES,
+        "app/views" => "**/*.{erb,haml,slim,jbuilder,builder,ruby}",
         "lib/tasks" => "**/*.rake"
       }.freeze
 

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -33,12 +33,8 @@ module RailsAiContext
       # Map well-known feature keywords to gem-based patterns
       AUTH_KEYWORDS = %w[auth authentication login signup signin session devise omniauth].freeze
 
-      # Cap per-directory file scans to avoid unbounded work on large monorepos.
-      # Note: Dir.glob materialises the full path array before .first() truncates.
-      # the directory walk itself is unbounded; only per-file reading and processing
-      # is capped at MAX_SCAN_FILES. Applied to every discover_* method that walks
-      # the filesystem. Tool output notes when the cap is hit so the AI agent knows
-      # to narrow its feature keyword. v5.8.1 hardening; all glob sites in r2.
+      # Names are matched over every file a glob finds; only the files read per directory, and the
+      # matches listed per section, stop at MAX_SCAN_FILES, and the answer says where they did.
       MAX_SCAN_FILES = 500
       # The callers named under each service; rails_get_service_pattern(service:) lists more.
       CALLERS_SHOWN = 5
@@ -70,16 +66,16 @@ module RailsAiContext
         discover_services(root, pattern, lines, unread)
         discover_admin(root, pattern, lines)
         discover_jobs(ctx, pattern, lines)
-        discover_views(ctx, root, pattern, lines, unread)
+        discover_views(ctx, root, pattern, lines)
         discover_stimulus(ctx, pattern, lines)
-        _feature_tests, all_tests, tests_truncated = discover_tests(root, pattern, lines, unread)
+        all_tests = discover_tests(root, pattern, lines)
         discover_related_models(ctx, matched_models, lines)
         discover_concerns(ctx, matched_models, lines)
         discover_callbacks(ctx, matched_models, lines)
         discover_channels(ctx, pattern, lines)
         discover_mailers(ctx, pattern, lines)
-        discover_env_dependencies(root, pattern, matched_models, lines, unread)
-        discover_test_gaps(root, pattern, matched_models, ctx, all_tests || [], lines, unread, truncated: tests_truncated)
+        discover_env_dependencies(root, pattern, matched_models, lines)
+        discover_test_gaps(root, pattern, matched_models, ctx, all_tests, lines)
         discover_components(ctx, pattern, lines)
 
         # For auth-related keywords, also discover auth gems
@@ -103,11 +99,11 @@ module RailsAiContext
         text_response(lines.join("\n") + unread_note(unread))
       end
 
-      # Files past MAX_SCAN_FILES in a directory are never read, so a section that is missing may only be unread.
+      # Files past MAX_SCAN_FILES in a directory are matched by name alone, so a match by content may be missing.
       def self.unread_note(unread)
         return "" if unread.empty?
 
-        "\n\n_Only the first #{MAX_SCAN_FILES} files of a directory are read, so any past them in #{unread.sort.join(', ')} were not checked._"
+        "\n\n_Only the first #{MAX_SCAN_FILES} files of a directory are read, so any past them in #{unread.sort.join(', ')} were matched by name alone._"
       end
 
       # The names a keyword that matched nothing could have been.
@@ -123,12 +119,7 @@ module RailsAiContext
       class << self
         private
 
-        # The first MAX_SCAN_FILES of a glob; a directory holding more goes into `unread`.
-        def capped_glob(dir, pattern, real_root, label, unread)
-          files = safe_glob(dir, pattern, real_root)
-          unread << label if files.size > MAX_SCAN_FILES
-          files.first(MAX_SCAN_FILES)
-        end
+        def listed_suffix(found) = found.size > MAX_SCAN_FILES ? " - first #{MAX_SCAN_FILES} listed" : ""
 
         # A conditional skip names the condition it is taken out on.
         def inherited_filter_label(filter)
@@ -281,17 +272,17 @@ module RailsAiContext
 
           real_root = File.realpath(root).to_s
           real_dir = File.realpath(dir).to_s
-          candidates = capped_glob(dir, "**/*.rb", real_root, "app/services", unread)
-          # Prefer basename match (fast, no file read) and only fall back to
-          # a content scan for files whose basename doesn't match. This
-          # avoids reading every service file's full contents on large apps.
-          found = candidates.select do |path|
-            next true if feature_word_match?(File.basename(path, ".rb"), pattern)
+          files = safe_glob(dir, "**/*.rb", real_root)
+          # A name matches without a read; only the files whose name does not are read for the word.
+          by_name, rest = files.partition { |path| feature_word_match?(File.basename(path, ".rb"), pattern) }
+          unread << "app/services" if rest.size > MAX_SCAN_FILES
+          by_content = rest.first(MAX_SCAN_FILES).select do |path|
             File.size(path) < 50_000 && feature_word_match?(RailsAiContext::SafeFile.read(path), pattern)
           end
+          found = files & (by_name + by_content)
           return if found.empty?
 
-          services = found.filter_map do |path|
+          services = found.first(MAX_SCAN_FILES).filter_map do |path|
             source = RailsAiContext::SafeFile.read(path) or next
             # The path carries the namespace Zeitwerk expects, as rails_get_service_pattern reads it.
             constant = path.delete_prefix("#{real_dir}/").delete_suffix(".rb").camelize
@@ -302,7 +293,7 @@ module RailsAiContext
           named = services.select { |s| s[:name] }
           callers, callers_truncated = GetServicePattern.callers_of(named.to_h { |s| [ s[:name], s[:path] ] }, real_root)
 
-          lines << "## Services (#{found.size}#{unread.include?("app/services") ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
+          lines << "## Services (#{found.size}#{listed_suffix(found)})"
           services.each do |service|
             relative = service[:path].sub("#{real_root}/", "")
             methods = service[:name] ? service_methods(service[:source], service[:name]) : []
@@ -368,20 +359,19 @@ module RailsAiContext
         end
 
         # --- AF3: Views + Partials ---
-        def discover_views(ctx, root, pattern, lines, unread)
+        def discover_views(ctx, root, pattern, lines)
           views_dir = File.join(root, "app", "views")
           return unless Dir.exist?(views_dir)
 
           real_root = File.realpath(root).to_s
           real_views_dir = File.realpath(views_dir).to_s
-          candidates = capped_glob(views_dir, "**/*.{erb,haml,slim,jbuilder}", real_root, "app/views", unread)
-          found = candidates.select do |path|
+          found = safe_glob(views_dir, "**/*.{erb,haml,slim,jbuilder}", real_root).select do |path|
             feature_word_match?(path.sub("#{real_views_dir}/", ""), pattern)
           end
           return if found.empty?
 
-          lines << "## Views (#{found.size}#{unread.include?("app/views") ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
-          found.each do |path|
+          lines << "## Views (#{found.size}#{listed_suffix(found)})"
+          found.first(MAX_SCAN_FILES).each do |path|
             relative = path.sub("#{real_views_dir}/", "")
             source = RailsAiContext::SafeFile.read(path) or next
             line_count = source.lines.size
@@ -451,20 +441,17 @@ module RailsAiContext
           relative.sub(%r{(\A|/)(?:spec|test)_}, "\\1")
         end
 
-        # @return [Array(Array<String>, Array<String>, Boolean)] the tests the
-        #   feature word names, every test read (relative to the suite's root),
-        #   and whether a glob stopped at MAX_SCAN_FILES
-        def discover_tests(root, pattern, lines, unread)
+        # @return [Array<String>] every test in the suite, relative to the suite's root
+        def discover_tests(root, pattern, lines)
           real_root = File.realpath(root).to_s
           found = []
           all = []
-          truncated = false
 
           base = RailsAiContext::PathResolver.test_root(root)
           real_base = File.realpath(base).to_s
           [ File.join(base, "spec"), File.join(base, "test") ].each do |dir|
             next unless Dir.exist?(dir)
-            suffix_glob = capped_glob(dir, "**/*_{test,spec}.rb", real_base, File.basename(dir), unread)
+            suffix_glob = safe_glob(dir, "**/*_{test,spec}.rb", real_base)
             # The path, not the basename: the gap checker below matches this
             # way for the same reason, and a spec whose feature word is a
             # directory (billing/invoices/create_spec.rb) is the normal shape
@@ -472,20 +459,18 @@ module RailsAiContext
             suffix_glob.each do |path|
               found << path if feature_word_match?(relative_test_name(path, real_base), pattern)
             end
-            prefix_glob = capped_glob(dir, "**/{test,spec}_*.rb", real_base, File.basename(dir), unread)
+            prefix_glob = safe_glob(dir, "**/{test,spec}_*.rb", real_base)
             prefix_glob.each do |path|
               found << path if feature_word_match?(relative_test_name(path, real_base), pattern)
             end
             all.concat(suffix_glob, prefix_glob)
           end
-          truncated = unread.include?("spec") || unread.include?("test")
           found.uniq!
           all = all.uniq.map { |path| path.delete_prefix("#{real_base}/") }
-          return [ found, all, truncated ] if found.empty?
+          return all if found.empty?
 
-          header = "## Tests (#{found.size}#{truncated ? " - first #{MAX_SCAN_FILES} per glob scanned" : ""})"
-          lines << header
-          found.each do |path|
+          lines << "## Tests (#{found.size}#{listed_suffix(found)})"
+          found.first(MAX_SCAN_FILES).each do |path|
             relative = Pathname.new(path).relative_path_from(Pathname.new(real_root)).to_s
             source = RailsAiContext::SafeFile.read(path) or next
             test_count = source.each_line.count do |line|
@@ -494,19 +479,15 @@ module RailsAiContext
             lines << "- `#{relative}` (#{count_phrase(test_count, "test")})"
           end
           lines << ""
-          [ found, all, truncated ]
+          all
         rescue => e
-          RailsAiContext.debug_fail(e, [ [], [], false ], label: "discover_tests")
+          RailsAiContext.debug_fail(e, [], label: "discover_tests")
         end
 
         # --- Test coverage gaps ---
-        def discover_test_gaps(root, pattern, matched_models, ctx, test_files, lines, unread, truncated: false)
-          # A gap is a claim that something has no test, and a scan that stopped
-          # at MAX_SCAN_FILES cannot make it: Discourse has 1,672 spec files, so
-          # the first 500 missed the ones that cover the feature and every
-          # controller was reported as untested.
-          return if truncated
-
+        # A gap is a claim that something has no test, so it reads the name of every test in the suite:
+        # Discourse has 1,672 spec files, and the first 500 missed the ones that cover the feature.
+        def discover_test_gaps(root, pattern, matched_models, ctx, test_files, lines)
           gaps = []
           # Paths, not basenames: a namespaced name underscores to admin/badges,
           # which no basename can contain, so every namespaced controller was
@@ -540,7 +521,7 @@ module RailsAiContext
             path_dir = File.join(root, "app", dir)
             next unless Dir.exist?(path_dir)
 
-            capped_glob(path_dir, "**/*.rb", real_root, "app/#{dir}", unread).each do |path|
+            safe_glob(path_dir, "**/*.rb", real_root).each do |path|
               snake = File.basename(path, ".rb")
               next unless feature_word_match?(snake, pattern)
               next if test_basenames.any? { |t| t.include?(snake) }
@@ -667,15 +648,19 @@ module RailsAiContext
         end
 
         # --- AF9: Environment Dependencies ---
-        def discover_env_dependencies(root, pattern, matched_models, lines, unread)
+        def discover_env_dependencies(root, pattern, matched_models, lines)
           # Scan services, jobs, and model files for ENV references
           real_root = File.realpath(root).to_s
           dirs = %w[app/services app/jobs].map { |d| File.join(root, d) }.select { |d| Dir.exist?(d) }
           env_vars = Set.new
+          truncated = false
 
           dirs.each do |dir|
-            capped_glob(dir, "**/*.rb", real_root, dir.delete_prefix("#{root}/"), unread).each do |path|
-              next unless feature_word_match?(File.basename(path, ".rb"), pattern) || feature_word_match?(path, pattern)
+            matched = safe_glob(dir, "**/*.rb", real_root).select do |path|
+              feature_word_match?(File.basename(path, ".rb"), pattern) || feature_word_match?(path, pattern)
+            end
+            truncated ||= matched.size > MAX_SCAN_FILES
+            matched.first(MAX_SCAN_FILES).each do |path|
               source = RailsAiContext::SafeFile.read(path) or next
               source.scan(/ENV\[["']([^"']+)["']\]|ENV\.fetch\(["']([^"']+)["']\)/).each do |m|
                 env_vars << (m[0] || m[1])
@@ -684,7 +669,6 @@ module RailsAiContext
           end
           return if env_vars.empty?
 
-          truncated = dirs.any? { |dir| unread.include?(dir.delete_prefix("#{root}/")) }
           header = "## Environment Dependencies#{truncated ? " (first #{MAX_SCAN_FILES} per dir scanned)" : ""}"
           lines << header
           env_vars.sort.each { |v| lines << "- `#{v}`" }

data/lib/rails_ai_context/tools/diagnose.rb

@@ -220,7 +220,7 @@ module RailsAiContext
 
         # Next steps
         next_steps = [
-          (pointer("rails_get_edit_context", %(file:"#{file}", near:"#{parsed[:method_name] || line || parsed[:exception_class]}"), "to see the code.") if file),
+          (pointer("rails_get_edit_context", line ? %(file:"#{file}", line:#{line}) : %(file:"#{file}", near:"#{parsed[:method_name] || parsed[:exception_class]}"), "to see the code.") if file),
           (pointer("rails_search_code", %(pattern:"#{parsed[:method_name]}", match_type:"trace"), "to trace the method.") if parsed[:method_name])
         ].compact.map { |step| "_Use #{step}_" }
         if next_steps.any?
@@ -283,7 +283,7 @@ module RailsAiContext
           end
 
           # Extract method name from "undefined method `foo`" or "undefined method 'foo'"
-          if (m = result[:message].match(/undefined method [`'](\w+[?!]?)[`']/))
+          if (m = result[:message].match(/undefined method [`'](\w+[?!=]?|\[\]=?)[`']/))
             result[:method_name] = m[1]
           end
 
@@ -497,7 +497,7 @@ module RailsAiContext
           known = known_model_methods(model_data)
           # "published?" / "save!" resolve through the bare attribute name, so
           # compare without the trailing punctuation too.
-          base_name = method_name.to_s.sub(/[?!]\z/, "")
+          base_name = method_name.to_s.sub(/[?!=]\z/, "")
           return nil if known.include?(base_name) || known.include?(method_name.to_s)
 
           suggestion = find_closest_match(base_name, known)
@@ -575,7 +575,7 @@ module RailsAiContext
 
           if file && line
             add_section(lines, "Code Context", report_error: true) do
-              compose(GetEditContext, file: file, near: parsed[:method_name] || line.to_s)
+              compose(GetEditContext, file: file, near: parsed[:method_name], line: line)
             end
           end
 
@@ -616,12 +616,18 @@ module RailsAiContext
 
         # Regex because a lone source line is no program a listener can walk.
         def nil_receiver(file, line, method)
-          call = /((?:@@?|\$)?\w+)\.#{Regexp.escape(method)}(?![\w?!])/
+          name = method.chomp("=")
+          # A `%w[` literal is no index call, and in `a[:b][:c]` the nil one may be `a[:b]`.
+          call = if method.start_with?("[") then /(?<![%\w@$])((?:@@?|\$)?\w+)\[[^\[\]]*\](?!\[)/
+          elsif method.end_with?("=") then /((?:@@?|\$)?\w+)\.#{Regexp.escape(name)}\s*=(?!=)/
+          else /((?:@@?|\$)?\w+)\.#{Regexp.escape(method)}(?![\w?!])/
+          end
           located = RailsAiContext::SafePath.locate(file, under: rails_app.root.to_s)
           failing = line.to_i.positive? && located.ok? && RailsAiContext::SafeFile.read(located.realpath).to_s.lines[line.to_i - 1]
           return failing[call, 1] if failing
+          return nil if method.start_with?("[")
 
-          response_text(compose(GetEditContext, file: file, near: method))[call, 1]
+          response_text(compose(GetEditContext, file: file, near: ".#{name}"))[call, 1]
         end
 
         # Infer a specific diagnosis from the error + context

data/lib/rails_ai_context/tools/get_edit_context.rb

@@ -6,7 +6,7 @@ module RailsAiContext
       tool_name "rails_get_edit_context"
       description "Get targeted code context for surgical edits: returns matching lines with surrounding code and line numbers. " \
         "Use when: you need to edit a specific method or section without reading the entire file. " \
-        "Requires file:\"app/models/user.rb\" and near:\"def activate\" to locate the code region."
+        "Requires file:\"app/models/user.rb\" and near:\"def activate\" (or line:42) to locate the code region."
 
       input_schema(
         properties: {
@@ -21,9 +21,13 @@ module RailsAiContext
           context_lines: {
             type: "integer",
             description: "Lines of context above and below the match. Default: 5."
+          },
+          line: {
+            type: "integer",
+            description: "Show context_lines either side of this line number instead of searching for `near` (e.g. a line from a stack trace)."
           }
         },
-        required: %w[file near]
+        required: %w[file]
       )
 
       guide_row(
@@ -35,14 +39,14 @@ module RailsAiContext
 
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
 
-      def self.call(file:, near:, context_lines: 5, server_context: nil)
+      def self.call(file:, near: nil, context_lines: 5, line: nil, server_context: nil)
         # Reject empty parameters
         if file.nil? || file.strip.empty?
           return text_response("The `file` parameter is required. Provide a path relative to Rails root (e.g. 'app/models/post.rb').")
         end
 
-        if near.nil? || near.strip.empty?
-          return text_response("The `near` parameter is required. Provide a method name, keyword, or string to find.")
+        if line.nil? && (near.nil? || near.strip.empty?)
+          return text_response("The `near` or `line` parameter is required. Provide a method name, keyword, or string to find, or a line number.")
         end
 
         located = RailsAiContext::SafePath.locate(file, under: rails_app.root.to_s)
@@ -79,10 +83,13 @@ module RailsAiContext
         # start brought back a window where a wrong guess brought "not found".
         redacted = RailsAiContext::Redaction.redact_source_lines(source_lines.map(&:rstrip), path: file)
 
-        # Find all matching lines
-        matches = []
-        redacted.each_with_index do |line, idx|
-          matches << idx if line.include?(near)
+        at_line = line.to_i.between?(1, source_lines.size)
+        matches = if at_line
+          [ line.to_i - 1 ]
+        elsif near.nil? || near.strip.empty?
+          return empty_response("Line #{echo_input(line.to_s)} is not in #{file} (#{count_phrase(source_lines.size, "line")}).")
+        else
+          redacted.each_index.select { |idx| redacted[idx].include?(near) }
         end
 
         if matches.empty?
@@ -94,9 +101,10 @@ module RailsAiContext
         start_idx = [ match_idx - context_lines, 0 ].max
         end_idx = [ match_idx + context_lines, source_lines.size - 1 ].min
 
-        # If match is inside a method, expand to include the full method
+        # If match is inside a method, expand to include the full method; a line asked for keeps its
+        # window, which a 300-line method would push out of a caller's cut.
         method_start = find_method_start(source_lines, match_idx)
-        method_end = find_method_end(source_lines, method_start) if method_start
+        method_end = find_method_end(source_lines, method_start) if method_start && !at_line
         if method_start && method_end && source_lines[match_idx].match?(/\A\s*def\s/)
           # Match IS a method definition - show the complete method, no extra context
           start_idx = method_start

data/lib/rails_ai_context/tools/migration_advisor.rb

@@ -148,10 +148,7 @@ module RailsAiContext
         lines.concat(column_mention_lines(column)) if %w[remove_column rename_column change_type].include?(action) && column
 
         # Strong Migrations warnings (only when the gem is present in the project).
-        # add_association accepts the associated table via either `column` or
-        # `type` (see generate_add_association) - resolve the same way here.
-        warning_column = action == "add_association" ? (column || type) : column
-        lines.concat(strong_migrations_warnings(action, table, warning_column, options)) if strong_migrations_gem_present?
+        lines.concat(strong_migrations_warnings(action, table, column, options)) if strong_migrations_gem_present?
 
         text_response(lines.join("\n"))
       end
@@ -532,7 +529,8 @@ module RailsAiContext
           reference = written.to_s.singularize
           lines = []
           fk_column = "#{reference}_id"
-          if column_exists?(table, fk_column)
+          fk_column_exists = column_exists?(table, fk_column)
+          if fk_column_exists
             lines << "**Warning:** Column `#{fk_column}` already exists on `#{table}`. This migration will fail. Use `add_index` if you only need an index."
             lines << ""
           end
@@ -563,20 +561,76 @@ module RailsAiContext
             lines << ""
           end
 
-          foreign_key = if across || to_table.nil? then ""
-          elsif to_table == reference.pluralize then ", foreign_key: true"
-          else ", foreign_key: { to_table: :#{to_table} }"
+          composite = to_table && !across && composite_key(schema, to_table)
+          if composite
+            lines << "**Foreign key:** `#{to_table}` has the composite primary key (#{composite.join(', ')}), " \
+                     "which one column cannot reference, so the reference below has none."
+            lines << ""
           end
+
+          fk_target = to_table unless across || composite
+          foreign_key = fk_target ? foreign_key_option(schema, fk_target, reference) : ""
+          reference_call = "add_reference :#{table}, :#{reference}#{key_type_option(schema, table, to_table)}"
           lines << "```ruby"
           lines << "class Add#{written.camelize}To#{table.camelize} < ActiveRecord::Migration[#{rails_version}]"
           lines << "  def change"
-          lines << "    add_reference :#{table}, :#{reference}#{key_type_option(schema, to_table)}#{foreign_key}"
+          lines << "    #{reference_call}#{foreign_key}"
           lines << "  end"
           lines << "end"
           lines << "```"
           lines << ""
           lines << "**Reversible:** Yes"
           lines.concat(association_model_lines(table, reference, to_table))
+          # A migration that fails on its existing column has nothing to make safe.
+          lines.concat(association_strong_migrations_lines(table, reference, reference_call, fk_target, schema)) if strong_migrations_gem_present? && !fk_column_exists
+          lines
+        end
+
+        # The add_reference above as strong_migrations wants it on each
+        # database: the index and the foreign key are what it checks.
+        def association_strong_migrations_lines(table, reference, reference_call, fk_target, schema)
+          column_option = ", column: :#{reference}_id"
+          target_key = custom_primary_key(schema, fk_target) if fk_target
+          add_foreign_key_call = "add_foreign_key :#{table}, :#{fk_target}#{column_option}#{", primary_key: :#{target_key}" if target_key}"
+          warnings = case family(table).key
+          when :postgresql
+            # strong_migrations before 2.5.2 flags any key inside add_reference, so the key goes on its own.
+            unvalidated_key_step = " and `#{add_foreign_key_call}, validate: false`" if fk_target
+            steps = [
+              "**`add_reference` builds its index without `algorithm: :concurrently`**, which blocks writes" \
+              "#{", and its foreign key checks every existing row under a `SHARE ROW EXCLUSIVE` lock on both tables" if fk_target}. Instead:",
+              "  1. `disable_ddl_transaction!` at the top of the migration, then `#{reference_call}, index: { algorithm: :concurrently }`#{unvalidated_key_step}"
+            ]
+            steps << "  2. In a separate migration: `validate_foreign_key :#{table}, :#{fk_target}#{column_option}`" if fk_target
+            steps
+          when :mysql
+            if fk_target && strong_migrations_checks_mysql_foreign_keys?
+              [
+                "**`add_reference` with a foreign key blocks writes on both tables.** Add the reference without one, `#{reference_call}`, " \
+                "and the key in a separate migration. If every row is valid and migrations do not run through a connection pooler:",
+                "```ruby",
+                "class Add#{reference.camelize}ForeignKeyTo#{table.camelize} < ActiveRecord::Migration[#{rails_version}]",
+                "  def up",
+                "    safety_assured do",
+                "      execute \"SET SESSION foreign_key_checks = 0\"",
+                "      #{add_foreign_key_call}",
+                "    ensure",
+                "      execute \"SET SESSION foreign_key_checks = 1\"",
+                "    end",
+                "  end",
+                "",
+                "  def down",
+                "    remove_foreign_key :#{table}#{column_option}",
+                "  end",
+                "end",
+                "```"
+              ]
+            end
+          when :sqlite then nil # strong_migrations checks no foreign key on SQLite
+          else
+            [ "**The foreign key from `add_reference` validates existing rows**, which can block writes on both tables while it runs." ] if fk_target
+          end
+          strong_migrations_section(warnings)
         end
 
         # The belongs_to and has_many the reference wants, in the models that
@@ -617,18 +671,53 @@ module RailsAiContext
           Payload.schema_tables(schema).any? { |_, table, _| table.to_s == name.to_s }
         end
 
-        # The primary key type of a table when it is not the integer Rails defaults to.
-        def custom_key_type(table_data)
+        def key_column(table_data)
           keys = Array(table_data && table_data[:columns]).select { |c| c[:primary_key] }
-          type = keys.first[:type].to_s if keys.size == 1
-          type unless type.nil? || %w[bigint integer].include?(type)
+          keys.first if keys.size == 1
         end
 
-        # ", type: :uuid" for a reference to a table keyed that way; a table the schema lacks is keyed as the app's tables are.
-        def key_type_option(schema, to_table)
+        # The key type of a table when a reference would not get it by default: bigint never, integer unless counted as default.
+        def custom_key_type(table_data, integer_is_default: true)
+          type = key_column(table_data)&.dig(:type)&.to_s
+          type unless type.nil? || type == "bigint" || (integer_is_default && type == "integer")
+        end
+
+        # A reference takes the column type of a serial key, never a sequence of its own.
+        SERIAL_COLUMN_TYPES = { "serial" => "integer", "smallserial" => "smallint", "bigserial" => nil }.freeze
+
+        # The type, limit and sign a reference needs to match its key, which a MySQL foreign key requires;
+        # only SQLite types every integer alike. A table the schema lacks is keyed as the app's tables are.
+        def key_type_option(schema, table, to_table)
+          database = family(table).key
           target = to_table && schema_known?(schema) && Payload.schema_table(schema, to_table)
-          type = target ? custom_key_type(target) : app_key_type(schema)
-          type ? ", type: :#{type}" : ""
+          key = key_column(target) if target
+          type = target ? custom_key_type(target, integer_is_default: database == :sqlite) : app_key_type(schema)
+          type = SERIAL_COLUMN_TYPES.fetch(type, type)
+          limit = key[:limit] if key && type == "integer"
+          unsigned = key && key[:unsigned] && database == :mysql
+          "#{", type: :#{type}" if type}#{", limit: #{limit}" if limit}#{", unsigned: true" if unsigned}"
+        end
+
+        # Rails points a foreign key at the reference pluralized and at its
+        # `id`, so another table, or a table keyed by another column, is named.
+        def foreign_key_option(schema, to_table, reference)
+          key = custom_primary_key(schema, to_table)
+          options = [ ("to_table: :#{to_table}" if to_table != reference.pluralize), ("primary_key: :#{key}" if key) ].compact
+          options.empty? ? ", foreign_key: true" : ", foreign_key: { #{options.join(', ')} }"
+        end
+
+        def custom_primary_key(schema, to_table)
+          key = primary_key(schema, to_table)
+          key if key.is_a?(String) && key != "id"
+        end
+
+        def composite_key(schema, to_table)
+          key = primary_key(schema, to_table)
+          key if key.is_a?(Array)
+        end
+
+        def primary_key(schema, to_table)
+          schema_known?(schema) ? Payload.schema_table(schema, to_table)&.dig(:primary_key) : nil
         end
 
         # The key type more than half of the app's tables share, when it is not Rails' default.
@@ -698,7 +787,14 @@ module RailsAiContext
               name = parts[0]&.strip
               type = parts[1]&.strip || "string"
               if type == "references"
-                lines << "      t.references :#{name}#{key_type_option(schema, name.to_s.pluralize)}, foreign_key: true"
+                to_table = name.to_s.pluralize
+                missing = schema_known?(schema) && !table_in_schema?(schema, to_table)
+                composite = !missing && composite_key(schema, to_table)
+                foreign_key = if missing then " # no foreign key: the schema has no #{to_table} table"
+                elsif composite then " # no foreign key: #{to_table} has the composite primary key (#{composite.join(', ')})"
+                else foreign_key_option(schema, to_table, name)
+                end
+                lines << "      t.references :#{name}#{key_type_option(schema, table, to_table)}#{foreign_key}"
               else
                 lines << "      t.#{type} :#{name}"
               end
@@ -719,7 +815,8 @@ module RailsAiContext
         # at migration runtime, so AI agents see them at code-generation time. Only fires
         # when the gem is actually present in the project's Gemfile.lock.
         #
-        # Catalog covers the most common breaking-change patterns (columns, indexes, FKs).
+        # Catalog covers the most common breaking-change patterns (columns, indexes);
+        # add_association's warning lives with the reference it rewrites.
         # Not exhaustive - see https://github.com/ankane/strong_migrations#checks for the full list.
         def strong_migrations_warnings(action, table, column, options)
           warnings = case action
@@ -751,26 +848,6 @@ module RailsAiContext
                 "Use `add_index :#{table}, :#{column}, algorithm: :concurrently` and add `disable_ddl_transaction!` at the top of the migration."
               ]
             end
-          when "add_association"
-            case family(table).key
-            when :mysql
-              [
-                "**`add_foreign_key` blocks writes on both tables while validating existing rows.** MySQL/MariaDB has no `validate: false` + separate-validation two-step like Postgres.",
-                "If you're certain all rows are valid, wrap in `safety_assured` and drop `foreign_key_checks` for the duration:",
-                "  1. `execute \"SET SESSION foreign_key_checks = 0\"`",
-                "  2. `add_foreign_key :#{table}, :#{column}`",
-                "  3. `execute \"SET SESSION foreign_key_checks = 1\"`"
-              ]
-            when :postgresql
-              [
-                "**`add_foreign_key` validates existing rows by default**, which acquires a `SHARE ROW EXCLUSIVE` lock on both tables.",
-                "Safer two-step pattern:",
-                "  1. `add_foreign_key :#{table}, :#{column}, validate: false` (lock-free)",
-                "  2. In a separate migration: `validate_foreign_key :#{table}, :#{column}`"
-              ]
-            else
-              [ "**`add_foreign_key` validates existing rows by default**, which can block writes on both tables while it runs." ]
-            end
           when "add_column"
             if options.to_s.match?(/null:\s*false/) && !options.to_s.include?("default:")
               [
@@ -784,6 +861,10 @@ module RailsAiContext
             end
           end
 
+          strong_migrations_section(warnings)
+        end
+
+        def strong_migrations_section(warnings)
           return [] unless warnings&.any?
 
           [ "", "## Strong Migrations Warnings", "", "_The `strong_migrations` gem is in your Gemfile - these warnings match what it would raise at migration runtime._", "" ] + warnings
@@ -795,6 +876,14 @@ module RailsAiContext
           RailsAiContext.debug_fail(e, false, label: "strong_migrations_gem_present?")
         end
 
+        # strong_migrations checks a MySQL foreign key from 2.7 on; an unlocked or unreadable version is taken as current.
+        def strong_migrations_checks_mysql_foreign_keys?
+          version = RailsAiContext::GemLock.for(rails_app.root).version("strong_migrations")
+          version.nil? || Gem::Version.new(version).release >= Gem::Version.new("2.7")
+        rescue => e
+          RailsAiContext.debug_fail(e, true, label: "strong_migrations_checks_mysql_foreign_keys?")
+        end
+
         # ignored_columns has to go on the class that owns the table, and
         # every STI class records that same table, so a child that sorts
         # earlier would otherwise win. The conventional name is the base.

data/lib/rails_ai_context/version.rb

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

metadata

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