rails-ai-context 5.30.2 → 5.31.0

data/lib/rails_ai_context/tools/query.rb

@@ -198,7 +198,7 @@ module RailsAiContext
         when "csv"
           format_csv(redacted)
         else
-          format_table(redacted)
+          format_table(redacted) + unbounded_note(result)
         end
 
         text_response(output)
@@ -312,16 +312,19 @@ module RailsAiContext
         # Build the combined list ONCE per call and dedupe.
         configured = Array(config.query_redacted_columns).map { |c| c.to_s.downcase }
         suffixed   = SENSITIVE_COLUMN_SUFFIXES.map(&:downcase)
-        # An app whose own column merely looks sensitive (oauth_applications.secret)
-        # exempts it here; the built-in list is frozen and cannot be subtracted from.
-        allowed    = Array(config.query_allowed_columns).map { |c| c.to_s.downcase }
-        ((configured + suffixed).uniq - allowed).each do |col|
+        ((configured + suffixed).uniq - allowed_columns.to_a).each do |col|
           next if col.empty?
           return col if down.match?(/\b#{Regexp.escape(col)}\b/)
         end
         nil
       end
 
+      # An app whose own column merely looks sensitive (oauth_applications.secret)
+      # exempts it by name, from the pre-query check and from result redaction alike.
+      private_class_method def self.allowed_columns
+        Array(config.query_allowed_columns).to_set { |c| c.to_s.downcase }
+      end
+
       # ── Database-level execution (Layer 2) ──────────────────────────
       private_class_method def self.execute_safely(sql, row_limit, timeout_seconds)
         conn = ActiveRecord::Base.connection
@@ -383,29 +386,115 @@ module RailsAiContext
         result
       end
 
+      # sqlite3-ruby cannot interrupt a running statement, so a killable child runs it instead.
       private_class_method def self.execute_sqlite(conn, sql, timeout)
-        raw = conn.raw_connection
+        if (path = sqlite_fork_path(conn))
+          begin
+            return execute_sqlite_in_child(conn, path, sql, timeout)
+          rescue ActiveRecord::StatementInvalid => e
+            raise unless e.message.match?(SQLITE_APP_CONNECTION_ONLY)
+          end
+        end
+
         result = nil
         begin
           conn.execute("PRAGMA query_only = ON")
-          # SQLite has no native statement timeout. Use a progress handler
-          # to abort queries that run too long (checked every 1000 VM steps).
-          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
-          if raw.respond_to?(:set_progress_handler)
-            raw.set_progress_handler(1000) do
-              if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
-                1 # non-zero = abort
-              else
-                0
-              end
-            end
-          end
           result = conn.select_all(sql)
         ensure
-          raw.set_progress_handler(0, nil) if raw.respond_to?(:set_progress_handler)
           conn.execute("PRAGMA query_only = OFF")
         end
-        result
+        ResultProxy.new(result.columns, result.rows, true)
+      end
+
+      # Errors from state only the app's own connection has: registered functions,
+      # virtual table modules, collations, an encryption key.
+      SQLITE_APP_CONNECTION_ONLY = /no such (?:function|module|collation)|file is not a database/i
+
+      # A row-capped result is far below this; a larger prefix is a corrupt one.
+      SQLITE_MAX_RESULT_BYTES = 1 << 30
+
+      private_class_method def self.read_before(reader, size, deadline)
+        data = "".b
+        while data.bytesize < size
+          left = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          raise ActiveRecord::StatementInvalid, "SQLite query exceeded the statement timeout" unless left.positive? && IO.select([ reader ], nil, nil, left)
+
+          chunk = reader.read_nonblock([ size - data.bytesize, 1 << 16 ].min, exception: false)
+          raise ActiveRecord::StatementInvalid, "the SQLite query process exited without a result" if chunk.nil?
+
+          data << chunk unless chunk == :wait_readable
+        end
+        data
+      end
+
+      # nil for an in-memory or temporary database, or where there is no fork.
+      private_class_method def self.sqlite_fork_path(conn)
+        return nil unless Process.respond_to?(:fork)
+
+        path = conn.raw_connection.filename("main").to_s
+        path unless path.empty?
+      end
+
+      private_class_method def self.execute_sqlite_in_child(conn, path, sql, timeout)
+        parent = Process.pid
+        extensions = Array(conn.pool.db_config.configuration_hash[:extensions]).map { |ext| (ext.is_a?(String) && ext.safe_constantize) || ext }
+        # sqlite3 2.x warns in every child that inherits a writable handle; Rails 8 silences it the same way.
+        SQLite3::ForkSafety.suppress_warnings! if defined?(SQLite3::ForkSafety)
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        reader, writer = IO.pipe.each(&:binmode)
+        pid = fork { answer_in_child(reader, writer, path, sql, timeout, extensions) }
+        writer.close
+        read_child_result(reader, deadline)
+      ensure
+        # Also reached in a child whose fork hooks raised: it must not carry on as a second server.
+        exit!(1) if parent && Process.pid != parent
+        reader&.close
+        writer&.close
+        reap_child(pid) if pid
+      end
+
+      # Writes the length-prefixed result and exits without the parent's at_exit hooks.
+      private_class_method def self.answer_in_child(reader, writer, path, sql, timeout, extensions)
+        reader.close
+        payload = begin
+          db = SQLite3::Database.new(path, readonly: true, extensions: extensions)
+          db.busy_timeout = (timeout * 1000).to_i
+          stmt = db.prepare(sql)
+          [ :ok, stmt.columns, stmt.to_a ]
+        rescue => e
+          [ :error, "#{e.class}: #{e.message}" ]
+        end
+        bytes = Marshal.dump(payload)
+        writer.write([ bytes.bytesize ].pack("Q>"), bytes)
+      ensure
+        exit!(0)
+      end
+
+      # Read by length, not to EOF: any other process forked meanwhile holds a copy of the writer.
+      private_class_method def self.read_child_result(reader, deadline)
+        size = read_before(reader, 8, deadline).unpack1("Q>")
+        status, *rest = begin
+          raise ArgumentError, "result length out of range" if size > SQLITE_MAX_RESULT_BYTES
+
+          Marshal.load(read_before(reader, size, deadline))
+        rescue ArgumentError, TypeError
+          raise ActiveRecord::StatementInvalid, "the SQLite query process exited without a result"
+        end
+        raise ActiveRecord::StatementInvalid, rest.first if status == :error
+
+        ActiveRecord::Result.new(*rest)
+      end
+
+      # KILL: TERM cannot land while `step` holds the GVL, and would run inherited at_exit hooks.
+      # Runs in an ensure, so it rescues everything: nothing here may replace the query's own error.
+      private_class_method def self.reap_child(pid)
+        Process.kill(:KILL, pid) rescue nil
+        Process.wait(pid) rescue nil
+      end
+
+      private_class_method def self.unbounded_note(result)
+        result.is_a?(ResultProxy) && result.unbounded ? UNBOUNDED_SQLITE_NOTE : ""
       end
 
       # ── EXPLAIN execution ────────────────────────────────────────────
@@ -462,7 +551,7 @@ module RailsAiContext
         lines << parsed[:raw]
         lines << "```"
 
-        text_response(lines.join("\n"))
+        text_response(lines.join("\n") + unbounded_note(result))
       rescue ActiveRecord::StatementInvalid => e
         text_response("EXPLAIN failed: #{clean_error_message(e.message)}")
       end
@@ -592,14 +681,15 @@ module RailsAiContext
 
       # ── Column redaction (Layer 4) ──────────────────────────────────
       private_class_method def self.redact_results(result)
-        redacted_cols = config.query_redacted_columns.map(&:downcase).to_set
+        allowed = allowed_columns
+        redacted_cols = config.query_redacted_columns.map(&:downcase).to_set - allowed
+        encrypted_cols = Set.new
 
-        # Auto-redact columns declared with `encrypts` in models
         models_data = cached_context&.dig(:models)
         if models_data.is_a?(Hash)
           models_data.each_value do |data|
             next unless data.is_a?(Hash)
-            (data[:encrypts] || []).each { |col| redacted_cols << col.to_s.downcase }
+            (data[:encrypts] || []).each { |col| encrypted_cols << col.to_s.downcase }
           end
         end
         columns = result.columns
@@ -609,8 +699,9 @@ module RailsAiContext
         sensitive_suffixes = %w[password secret token key digest hash].freeze
         redacted_indices = columns.each_with_index.filter_map { |col, i|
           col_down = col.downcase
-          i if redacted_cols.include?(col_down) ||
-               sensitive_suffixes.any? { |suffix| col_down.end_with?(suffix) || col_down.include?("password") || col_down.include?("secret") || col_down.include?("token") }
+          i if encrypted_cols.include?(col_down) || redacted_cols.include?(col_down) ||
+               (!allowed.include?(col_down) &&
+                sensitive_suffixes.any? { |suffix| col_down.end_with?(suffix) || col_down.include?("password") || col_down.include?("secret") || col_down.include?("token") })
         }
 
         return result if redacted_indices.empty?
@@ -702,8 +793,11 @@ module RailsAiContext
         message.lines.first&.strip || message.strip
       end
 
-      # Quacks like ActiveRecord::Result for redacted output.
-      ResultProxy = Struct.new(:columns, :rows)
+      # Quacks like ActiveRecord::Result for redacted output, or for a SQLite
+      # query that ran in-process with no time limit.
+      ResultProxy = Struct.new(:columns, :rows, :unbounded)
+      UNBOUNDED_SQLITE_NOTE = "\n\n_This SQLite query ran without a time limit: query_timeout needs a file-backed database, " \
+        "a platform with fork, and nothing that only the app's own connection has._"
     end
   end
 end

data/lib/rails_ai_context/tools/search_code.rb

@@ -21,6 +21,20 @@ module RailsAiContext
 
       TEST_DIRS = %w[test/ spec/ features/].freeze
       MATCH_FIELD_SEPARATOR = "\x1f"
+      # A comment line by the file's own syntax. `#{` and ` * ` are Ruby code;
+      # `#id` is a selector in a stylesheet and an element in Haml or Slim.
+      HASH_COMMENT = /\A\s*(?:#(?!\{)|<%#)/
+      JS_COMMENT_OPEN = %r{\A\s*(?://|/\*)}
+      JS_COMMENT = Regexp.union(JS_COMMENT_OPEN, /\A\s*\*\s/)
+      CSS_NOT_A_CALL = %r{\A\s*(?:/\*|\*\s|#)}
+      STYLESHEET_LINE = Regexp.union(CSS_NOT_A_CALL, %r{\A\s*//})
+      NOT_A_CALL_LINE = {
+        ".erb" => Regexp.union(HASH_COMMENT, JS_COMMENT_OPEN),
+        ".haml" => %r{\A\s*(?:-#|/)},
+        ".slim" => %r{\A\s*/},
+        ".css" => CSS_NOT_A_CALL
+      }.merge(%w[.scss .sass .less].to_h { |ext| [ ext, STYLESHEET_LINE ] })
+       .merge(%w[.js .jsx .mjs .cjs .ts .tsx .mts .cts .vue .svelte].to_h { |ext| [ ext, JS_COMMENT ] }).freeze
 
       tool_name "rails_search_code"
       description "Search the Rails codebase with smart modes. " \
@@ -114,14 +128,14 @@ module RailsAiContext
           cleaned = pattern.sub(/\A\s*def\s+/, "")
           escaped = literal(cleaned)
           # `def\s+` already anchors the left edge, so only a trailing boundary.
-          exact_match ? "^\\s*def\\s+(self\\.)?#{escaped}#{trailing_boundary(cleaned)}" : "^\\s*def\\s+(self\\.)?#{escaped}"
+          exact_match ? "^\\s*def\\s+(self\\.)?#{escaped}#{RailsAiContext::MethodName.definition_end(cleaned)}" : "^\\s*def\\s+(self\\.)?#{escaped}"
         when "class"
           cleaned = pattern.sub(/\A\s*(class|module)\s+/, "")
           escaped = literal(cleaned)
           # `\w*` stays unbounded so a CamelCase prefix still resolves.
           exact_match ? "^\\s*(class|module)\\s+\\w*#{escaped}#{trailing_boundary(cleaned)}" : "^\\s*(class|module)\\s+\\w*#{escaped}"
         when "call"
-          exact_match ? exact_pattern(pattern) : pattern
+          exact_match ? method_call_pattern(pattern) : pattern
         else
           exact_match ? exact_pattern(pattern) : pattern
         end
@@ -174,8 +188,10 @@ module RailsAiContext
         end
         all_results, truncated = cap_results(fetched)
 
-        # Filter out definitions for match_type:"call"
-        all_results.reject! { |r| r[:content].match?(/\A\s*def\s/) } if match_type == "call"
+        # A definition or comment line stays as context, never as a call site.
+        if match_type == "call"
+          all_results.map! { |r| match_row?(r) && not_a_call_site?(r) ? r.merge(match: false) : r }
+        end
         all_results = confirmed_rows(all_results, root, build_regexp(search_pattern, timeout: 1), context_lines)
 
         if all_results.empty?
@@ -249,6 +265,10 @@ module RailsAiContext
         "#{leading_boundary(pattern)}#{literal(pattern)}#{trailing_boundary(pattern)}"
       end
 
+      private_class_method def self.method_call_pattern(name)
+        "#{leading_boundary(name)}#{literal(name)}#{RailsAiContext::MethodName.call_end(name)}"
+      end
+
       # Regexp.escape writes a space as `\ `, which ripgrep 13 rejects as an
       # unknown escape; a bare space means the same to both engines.
       private_class_method def self.literal(text)
@@ -310,11 +330,6 @@ module RailsAiContext
           cmd << "--glob=!#{p}"
         end
 
-        # Block sensitive files from search results
-        RailsAiContext.configuration.sensitive_patterns.each do |p|
-          cmd << "--glob=!#{p}"
-        end
-
         ai_context_paths.each do |p|
           cmd << "--glob=!#{p}"
         end
@@ -336,18 +351,19 @@ module RailsAiContext
         cmd << pattern
         cmd << search_path
 
-        output, status = Open3.capture2(*cmd, err: File::NULL)
+        output, err, status = Open3.capture3(*cmd)
 
         # rg exits 1 for "no matches" and 2 for any error, including one it
         # recovered from - an unreadable file in the tree - and it still
         # prints every match it found. An rg too old for a flag prints
         # nothing, so an empty result from a failed run is the one worth
         # rerunning; a full one is kept and the answer says an error was hit.
-        failed = !(status.success? || status.exitstatus == 1)
+        failed = !(status.success? || status.exitstatus == 1) && rg_error_outside_sensitive?(err, root)
         if failed && output.empty?
           return search_with_ruby(pattern, search_path, file_type, max_results, root, ctx_lines, exclude_tests: exclude_tests)
         end
 
+        # SafePath, not an rg glob, drops sensitive files: a glob cannot exempt a placeholder.
         rows = parse_rg_output(output, root)
           .reject { |r| sensitive_file?(r[:file]) }
           .first(max_results)
@@ -356,6 +372,18 @@ module RailsAiContext
         [ [ { file: "error", line_number: 0, content: e.message } ], false ]
       end
 
+      # rg opens sensitive files too, and one it cannot read is not an error
+      # the answer reports. A line that names no path counts as an error.
+      private_class_method def self.rg_error_outside_sensitive?(err, root)
+        lines = err.to_s.scrub.lines.map(&:chomp).reject(&:empty?)
+        return true if lines.empty?
+
+        lines.any? do |line|
+          path = line.delete_prefix("rg: ")[/\A(.+?): [^:]*\(os error \d+\)\z/, 1]
+          path.nil? || !sensitive_file?(path.delete_prefix("#{root}/"))
+        end
+      end
+
       private_class_method def self.search_with_ruby(pattern, search_path, file_type, max_results, root, ctx_lines = 0, exclude_tests: false)
         results = []
         search_error = false
@@ -452,14 +480,17 @@ module RailsAiContext
       # runs on the raw file, so a hit there would confirm what the secret starts with. Context rows
       # stay only beside a real hit, so a right guess shows what a wrong one does.
       private_class_method def self.confirmed_rows(rows, root, regex, ctx_lines)
-        kept = rows.zip(redact_rows(rows, root)).map do |raw, row|
-          hidden = match_row?(row) && raw[:content].to_s.chomp.match?(regex) && !row[:content].match?(regex)
-          hidden ? row.merge(match: false) : row
+        redacted_rows = redact_rows(rows, root)
+        kept = begin
+          rows.zip(redacted_rows).map do |raw, row|
+            hidden = match_row?(row) && raw[:content].to_s.chomp.match?(regex) && !row[:content].match?(regex)
+            hidden ? row.merge(match: false) : row
+          end
+        rescue Regexp::TimeoutError
+          redacted_rows
         end
         hits = kept.select { |r| match_row?(r) }.group_by { |r| r[:file] }
         kept.select { |r| match_row?(r) || hits.fetch(r[:file], []).any? { |h| (h[:line_number] - r[:line_number]).abs <= ctx_lines } }
-      rescue Regexp::TimeoutError
-        redact_rows(rows, root)
       end
 
       private_class_method def self.redacted(row)
@@ -470,6 +501,18 @@ module RailsAiContext
         row[:match] != false
       end
 
+      # A definition or a comment line names a method without calling it.
+      private_class_method def self.not_a_call_site?(row)
+        content = row[:content].to_s
+        return true if content.match?(/\A\s*def\s/)
+
+        ext = File.extname(row[:file].to_s)
+        # A live ERB tag runs whatever comment surrounds it.
+        return false if ext == ".erb" && content.match?(/<%(?!#)/)
+
+        content.match?(NOT_A_CALL_LINE.fetch(ext, HASH_COMMENT))
+      end
+
       private_class_method def self.match_count(rows)
         rows.count { |r| match_row?(r) }
       end
@@ -523,7 +566,7 @@ module RailsAiContext
         lines = [ "# Trace: `#{cleaned}`", "" ]
 
         # 1. Find the definition
-        def_pattern = "^\\s*def\\s+(self\\.)?#{literal(cleaned)}#{trailing_boundary(cleaned)}"
+        def_pattern = "^\\s*def\\s+(self\\.)?#{literal(cleaned)}#{RailsAiContext::MethodName.definition_end(cleaned)}"
         def_results, = quick_search(def_pattern, search_path, root, 10, exclude_tests)
 
         if def_results.any?
@@ -569,11 +612,10 @@ module RailsAiContext
         end
 
         # 2. Find all callers (everywhere the method is referenced, excluding the def line)
-        call_pattern = exact_pattern(cleaned)
+        call_pattern = method_call_pattern(cleaned)
         call_rows, = quick_search(call_pattern, search_path, root, max_results_cap + 1, exclude_tests)
         call_results, call_truncated = cap_results(call_rows)
-        # A `#` line mentioning the method is prose about it, not a call site.
-        callers = call_results.reject { |r| r[:content].match?(/\A\s*(def\s|#)/) }
+        callers = call_results.reject { |r| not_a_call_site?(r) }
 
         # Exclude the definition file+line to avoid self-reference
         def_locations = def_results.map { |r| "#{r[:file]}:#{r[:line_number]}" }.to_set
@@ -679,9 +721,9 @@ module RailsAiContext
         source.each_line do |line|
           in_private = true if line.match?(/\A\s*private\s*$/)
           next if in_private
-          if (m = line.match(/\A\s*def\s+((?:self\.)?\w+[?!]?)/))
+          if (m = line.match(/\A\s*def\s+((?:self\.)?\w+[?!=]?)/))
             name = m[1]
-            methods << name unless name == exclude_method || name.start_with?("initialize")
+            methods << name unless name.delete_prefix("self.") == exclude_method || name.start_with?("initialize")
           end
         end
         methods

data/lib/rails_ai_context/tools/search_docs.rb

@@ -197,8 +197,8 @@ module RailsAiContext
           cache_key = "#{topic['id']}_#{branch}.md"
           cache_file = cache_dir.join(cache_key)
 
-          # Use cached file if < 24 hours old
-          if File.exist?(cache_file) && (Time.now - File.mtime(cache_file)) < 86_400
+          # Use cached file if < 24 hours old; an empty one is a failed write, not a doc.
+          if File.size?(cache_file) && (Time.now - File.mtime(cache_file)) < 86_400
             return RailsAiContext::SafeFile.read(cache_file)
           end
 
@@ -214,9 +214,8 @@ module RailsAiContext
 
           max_fetch_bytes = 2_000_000 # 2MB safety cap
           if response.is_a?(Net::HTTPSuccess)
-            body = response.body
-            body = body.byteslice(0, max_fetch_bytes) if body.bytesize > max_fetch_bytes
-            File.write(cache_file, body)
+            body = response.body.byteslice(0, max_fetch_bytes).force_encoding(Encoding::UTF_8).scrub("?")
+            RailsAiContext::SafeFile.atomic_write(cache_file, body)
             body
           else
             "#{topic['summary']}\n→ #{url}\n_(fetch failed: HTTP #{response.code})_"

data/lib/rails_ai_context/tools/security_scan.rb

@@ -117,7 +117,9 @@ module RailsAiContext
           quiet: true,
           report_progress: false,
           min_confidence: min_confidence,
-          print_report: false
+          print_report: false,
+          # Forked parse workers cannot Marshal the Binding web-console's bindex hangs on a parse error.
+          parallel_checks: false
         }
         options[:run_checks] = Set.new(resolved_checks) if resolved_checks
 

data/lib/rails_ai_context/version.rb

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

data/lib/rails_ai_context.rb

@@ -44,7 +44,7 @@ module RailsAiContext
     # Global configuration
     attr_writer :configuration
 
-    # True while the stdio transport owns $stdout for JSON-RPC.
+    # True while a stdio session is serving JSON-RPC.
     attr_accessor :stdio_open
 
     def configuration

data/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.30.2",
+  "version": "5.31.0",
   "packages": [
     {
       "registryType": "mcpb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.30.2
+  version: 5.31.0
 platform: ruby
 authors:
 - crisnahine
@@ -378,7 +378,9 @@ files:
 - lib/rails_ai_context/introspectors/listeners/mixins_listener.rb
 - lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb
 - lib/rails_ai_context/introspectors/listeners/mount_listener.rb
+- lib/rails_ai_context/introspectors/listeners/owner_scope.rb
 - lib/rails_ai_context/introspectors/listeners/preview_paths_listener.rb
+- lib/rails_ai_context/introspectors/listeners/proc_literal_listener.rb
 - lib/rails_ai_context/introspectors/listeners/rake_task_dsl_listener.rb
 - lib/rails_ai_context/introspectors/listeners/route_files_listener.rb
 - lib/rails_ai_context/introspectors/listeners/routes_dsl_listener.rb
@@ -425,6 +427,7 @@ files:
 - lib/rails_ai_context/live_reload.rb
 - lib/rails_ai_context/mcp_config_generator.rb
 - lib/rails_ai_context/mcp_edge.rb
+- lib/rails_ai_context/method_name.rb
 - lib/rails_ai_context/middleware.rb
 - lib/rails_ai_context/migration_status.rb
 - lib/rails_ai_context/option_text.rb