rails-ai-context 5.35.2 → 5.36.1

data/lib/rails_ai_context/sql_gate.rb

@@ -121,7 +121,19 @@ module RailsAiContext
       integrity_check quick_check user_version application_id schema_version page_size page_count freelist_count
       encoding auto_vacuum journal_mode compile_options pragma_list
     ].to_set.freeze
-    SQLITE_CONNECTION_STATE = /\bpragma_(\w+)|\b(changes|total_changes|last_insert_rowid)\s*\(/i
+    SQLITE_COUNTER_CALL = /(?<![\w$])["'`\[]?(changes|total_changes|last_insert_rowid)["'`\]]?\s*\(/i
+    # A pragma function's name, bare or quoted, as one token.
+    SQLITE_PRAGMA_NAME = /\A["'`\[]?pragma_(\w+)["'`\]]?\z/i
+    # The clauses after which a comma at the same depth starts another table of a FROM list.
+    FROM_LIST_CLAUSES = %w[from join on using].freeze
+    CLAUSE_WORDS = %w[select from join on where group order having limit values using returning set union intersect except].freeze
+
+    # A double-quoted bare word, which MySQL under ANSI_QUOTES reads as a name and otherwise as a string.
+    BARE_QUOTED_WORD = /\A"\w+"\z/
+    # How a statement reads a session setting by name: SHOW, @@, @@SESSION. or @@LOCAL. (backquoted or not), current_setting('..').
+    SETTING_READ = /(?:\bshow\s+(?!global\b)|@@(?!global\s*\.)(?:(?:session|local)\s*\.\s*)?|current_setting\s*\(\s*')`?(\w+)/i
+    # A list of the session's settings, which names each in its rows or in the filter the statement puts on it.
+    SETTINGS_LIST = /\A\s*show\s+(?:(?:session|local)\s+)?variables\b|\b["`]?information_schema["`]?\s*\.\s*["`]?session_variables\b/i
 
     # Catalogs refused when a statement names them. A view over one runs, and the plan checks hold the
     # column that carries the credential (SecretColumns::CATALOG_CREDENTIALS) as a secret column.
@@ -176,6 +188,7 @@ module RailsAiContext
       pg_is_in_recovery pg_is_wal_replay_paused pg_get_wal_replay_pause_state
       pg_current_wal_lsn pg_current_wal_insert_lsn pg_current_wal_flush_lsn
       pg_last_wal_receive_lsn pg_last_wal_replay_lsn pg_last_xact_replay_timestamp
+      pg_sequence_last_value
     ].freeze
 
     # Any character past ASCII is an identifier character to SQLite and MySQL, a no-break space included.
@@ -228,6 +241,13 @@ module RailsAiContext
     # Every other statement is planned, as is whatever a leading EXPLAIN would run.
     NO_PLAN = /\A\s*(?:SHOW|DESCRIBE|DESC)\b/i
     EXPLAIN_PREFIX = /\A\s*EXPLAIN\s+(?:\([^)]*\)\s*)?(?:ANALYZE\s+)?(?:VERBOSE\s+)?/i
+    # A generic plan leaves $1 unbound, so the statement under it is planned only with the option. The server reads
+    # the option's last value, quoted or not, and anything but a false spelling of it is true.
+    EXPLAIN_OPTIONS = /\A\s*EXPLAIN\s*\(([^)]*)\)/i
+    GENERIC_PLAN_OPTION = /\bGENERIC_PLAN(?:\s+'?(\w*)'?)?\s*(?=,|\z)/i
+    FALSE_SPELLING = /\A(?:f(?:a(?:l(?:se?)?)?)?|no?|off?|0)\z/i
+    # The handler a sampling method names is never called by the statement, and the plan prints its arguments.
+    SAMPLING_METHOD = /\bTABLESAMPLE\s+(?:\w+\s*\.\s*)?\w+(?=\s*\()/i
 
     # A statement's text under a pointer. A lookbehind sees the text before the pointer, and where each dollar
     # tag last stands is read in one pass: a search for its closer from every opener is quadratic.
@@ -274,7 +294,9 @@ module RailsAiContext
       text, refusal = text_verdict(sql)
       return refuse(refusal) if refusal
       planned = @family.plan_checks? && !text.match?(NO_PLAN)
-      plan = @budget.spend { |left| @family.plan(@connection, text.sub(EXPLAIN_PREFIX, ""), timeout: left) } if planned
+      if planned
+        plan = @budget.spend { |left| @family.plan(@connection, text.sub(EXPLAIN_PREFIX, ""), timeout: left, generic: generic_plan?(text)) }
+      end
       if planned && plan.nil?
         return refuse("Blocked: the query is not run because its plan could not be read. On PostgreSQL " \
           "the plan shows which columns a query returns, so no query runs without one.")
@@ -310,6 +332,33 @@ module RailsAiContext
       out.strip
     end
 
+    # The session settings a statement reads: by name where the name is code, outside a quoted span and a comment,
+    # and every name a list of the session's settings shows in its rows or its filter.
+    def self.settings_read(sql, family, rows)
+      text = comment_free(sql, family)
+      code = mask_quoted(text, family) { true }
+      # On MySQL a double-quoted span other than a bare word is a string.
+      strings_blanked = mask_quoted(text, family) do |kind, span|
+        kind == :string || (family.mysql? && span.start_with?('"') && !span.match?(BARE_QUOTED_WORD))
+      end
+      read = text.enum_for(:scan, SETTING_READ).filter_map { $~[1] if code[$~.begin(0)] == text[$~.begin(0)] }
+      read += text.scan(/\w+/) + rows.flatten.map(&:to_s) if strings_blanked.match?(SETTINGS_LIST)
+      read.map(&:downcase)
+    end
+
+    # Every quoted span the block picks blanked to spaces of the same length, so positions still line up.
+    def self.mask_quoted(text, family, backslash: family.backslash_escapes?)
+      scanner = Scanner.new(text)
+      out = +""
+
+      until scanner.eos?
+        kind, span = quoted(scanner, family, backslash: backslash)
+        out << (span.nil? ? scanner.scan(UNQUOTED) || scanner.getch : yield(kind, span) ? " " * span.length : span)
+      end
+
+      out
+    end
+
     # The quoted span that opens where the scanner stands, as the family reads it: [:string or :quoted, the span], or nil.
     # brackets: whether [name] quotes a name in this text. backslash: whether one escapes the next character of a string.
     def self.quoted(scanner, family, brackets: family.sqlite?, backslash: family.backslash_escapes?)
@@ -420,7 +469,7 @@ module RailsAiContext
         return never_read_refusal(m.captures.compact.first)
       end
       if (m = listed(SYSTEM_SCHEMAS, mask_quoted(cleaned, :string)))
-        text_only = ->(kind, span) { kind == :string || (span.start_with?('"') && !span.match?(/\A"\w+"\z/)) }
+        text_only = ->(kind, span) { kind == :string || (span.start_with?('"') && !span.match?(BARE_QUOTED_WORD)) }
         return "#{never_read_refusal(m[1])} A name before a dot is read as that schema, so an alias named `#{m[1]}` needs another name." if
           listed(SYSTEM_SCHEMAS, mask_quoted(cleaned, &text_only))
 
@@ -429,8 +478,8 @@ module RailsAiContext
       end
       table, why = @secrets.unread_table_in(cleaned)
       return "Blocked: `#{table}` is not read: #{why}." if table
-      if (state = connection_state(cleaned))
-        return "Blocked: `#{state}` tells of the connection that runs it. rails_query runs a statement on a connection of its own and " \
+      if (state, view = connection_state(cleaned))
+        return "Blocked: `#{state}`#{", which the view `#{view}` reads," if view} tells of the connection that runs it. rails_query runs a statement on a connection of its own and " \
           "sets some of that connection's values itself, so the answer would not be the app's. A pragma function that describes the " \
           "schema or the database file runs, for example `pragma_table_info`."
       end
@@ -551,14 +600,55 @@ module RailsAiContext
         "#{" To read one setting, run SHOW with its name." if name.match?(/settings/i)}"
     end
 
+    # [name, view] for the first function that tells of the connection in the statement, or in a view it reaches,
+    # which SQLite runs on the same connection.
     def connection_state(cleaned)
       return nil unless @family.sqlite?
 
-      cleaned.to_enum(:scan, SQLITE_CONNECTION_STATE).filter_map do
-        pragma, counter = Regexp.last_match.captures
-        name = counter&.downcase || ("pragma_#{pragma.downcase}" unless SQLITE_FILE_PRAGMAS.include?(pragma.downcase))
-        name unless name.nil? || @secrets.knows?(name)
-      end.first
+      state = connection_state_in(cleaned)
+      return [ state, nil ] if state
+
+      @secrets.view_definitions_in(cleaned).each { |view, definition| (state = connection_state_in(definition)) and return [ state, view ] }
+      nil
+    end
+
+    # A counter is told by its call, a pragma function by its call or where a table stands (after FROM, JOIN, IN, a
+    # comma of a FROM list, a parenthesis that opens one, or a schema and a dot there); anywhere else it is a column.
+    def connection_state_in(cleaned)
+      # A table named like a counter does not hide the function, as one named like a pragma function does.
+      counter = cleaned[SQLITE_COUNTER_CALL, 1]
+      return counter.downcase if counter
+
+      list = tokens(cleaned)
+      clauses = [ nil ]
+      at_table = []
+      table_next = false
+      list.each_with_index do |(kind, text), i|
+        at_table << table_next
+        pragma = text.to_s[SQLITE_PRAGMA_NAME, 1]&.downcase if %i[word quoted string].include?(kind)
+        name = "pragma_#{pragma}" if pragma && !SQLITE_FILE_PRAGMAS.include?(pragma)
+        return name if name && (table_next || list[i + 1] == [ :punct, "(" ]) && !@secrets.knows?(name)
+
+        word = text.downcase if kind == :word
+        case [ kind, text ]
+        when [ :punct, "(" ]
+          clauses.push(table_next == :from ? "from" : nil)
+          table_next = table_next == :from && :from
+        when [ :punct, ")" ]
+          clauses.pop if clauses.size > 1
+          table_next = false
+        when [ :punct, "," ] then table_next = FROM_LIST_CLAUSES.include?(clauses.last) && :from
+        when [ :punct, "." ] then table_next = i.positive? && at_table[i - 1]
+        else table_next = (%w[from join].include?(word) && :from) || (word == "in" && :in)
+        end
+        clauses[-1] = word if CLAUSE_WORDS.include?(word)
+      end
+      nil
+    end
+
+    def generic_plan?(text)
+      value = text[EXPLAIN_OPTIONS, 1]&.scan(GENERIC_PLAN_OPTION)&.last or return false
+      value.first.to_s.empty? || !value.first.match?(FALSE_SPELLING)
     end
 
     def dump_refusal(function)
@@ -634,15 +724,7 @@ module RailsAiContext
     # only and positions still line up. only: the one kind to blank, :string or :quoted. With a block, the spans it picks.
     def mask_quoted(text, only = nil, &picks)
       picks ||= ->(kind, _span) { only.nil? || kind == only }
-      scanner = Scanner.new(text)
-      out = +""
-
-      until scanner.eos?
-        kind, span = self.class.quoted(scanner, @family, backslash: @backslash)
-        out << (span.nil? ? scanner.scan(UNQUOTED) || scanner.getch : picks.call(kind, span) ? " " * span.length : span)
-      end
-
-      out
+      self.class.mask_quoted(text, @family, backslash: @backslash, &picks)
     end
 
     # [kind, text] for each token of comment-free text: :word (bare, a keyword or a name), :quoted (a name in
@@ -853,7 +935,7 @@ module RailsAiContext
       foreign = plan.nodes.select { |node| node["Remote SQL"] }
       conds.concat(foreign.map { |node| remote_uses(node) }, local_names(foreign))
       # EXPLAIN prints no row of a VALUES list and no LIMIT, so the functions the text names are read too.
-      called = function_names(raw.map { |expr| expr.gsub(PLAN_LITERAL, "''") } + [ mask_sql_literals(text) ])
+      called = function_names(raw.map { |expr| expr.gsub(PLAN_LITERAL, "''") } + [ mask_sql_literals(text).gsub(SAMPLING_METHOD, "TABLESAMPLE ") ])
 
       # A view reaches a relation or a function the text check did not see.
       sources = plan.nodes.flat_map { |node| node.values_at("Relation Name", "Function Name") }.compact + called.to_a
@@ -882,7 +964,10 @@ module RailsAiContext
           "or set operation whose output the tool cannot map to a column, so it could leave " \
           "unredacted. Name the other columns you need; `#{col}` is never returned."
       end
-      if (fn = volatile_function(called))
+      if (fn = volatile_function(called)) && PG_VOLATILE_ALLOWLIST.include?(fn)
+        "Blocked: the database holds a VOLATILE function named #{fn} that rails_query cannot vouch for, so rails_query runs no " \
+          "call of that name. Its list of read-only VOLATILE functions trusts the name for the server's own function or a C function alone."
+      elsif fn
         "Blocked: function #{fn} is VOLATILE (pg_proc.provolatile = 'v') and not on " \
           "rails_query's list of read-only VOLATILE functions, so it is not run. Some VOLATILE " \
           "functions change server or session state in ways a read-only transaction does not " \
@@ -966,6 +1051,11 @@ module RailsAiContext
     # pin it. A column handed to a node that reads by name and names it nowhere (`count(*)`) is read by nothing.
     def laundered_secret_column(plan)
       top = secret_base_columns(plan, plan.output.flatten)
+      # A set operation compares every column its inputs hand up, so a row of guesses tests a secret value.
+      plan.nodes.select { |node| node["Node Type"] == "SetOp" }.each do |node|
+        handed = ([ node ] + Array(node["Plans"])).flat_map { |held| Array(held["Output"]) }
+        (col = @secrets.in_schema.find { |name| names?(handed, name) }) and return col
+      end
       plan.nodes.each do |node|
         reader = plan.reader(node)
         secret_base_columns(plan, Array(node["Output"])).each do |var|
@@ -990,15 +1080,18 @@ module RailsAiContext
       exprs.each_with_object(Set.new) { |expr, names| expr.scan(/([A-Za-z_]\w*)\s*\(/) { |(fn)| names << fn.downcase } }
     end
 
+    # A name on the read-only list vouches for the server's own function or a C function alone: while the database holds a
+    # VOLATILE function of that name in another language outside pg_catalog, every call of the name is refused.
     def volatile_function(called)
-      names = called - PG_VOLATILE_ALLOWLIST
-      return nil if names.empty?
+      return nil if called.empty?
 
-      quoted = names.map { |n| @connection.quote(n) }.join(", ")
+      quoted, listed = [ called, PG_VOLATILE_ALLOWLIST ].map { |names| names.map { |n| @connection.quote(n) }.join(", ") }
       @budget.spend do |left|
         @family.bounded(@connection, timeout: left) do
           @connection.select_values(
-            "SELECT DISTINCT lower(proname) FROM pg_proc WHERE lower(proname) IN (#{quoted}) AND provolatile = 'v'"
+            "SELECT DISTINCT lower(p.proname) FROM pg_proc p JOIN pg_language l ON l.oid = p.prolang " \
+            "WHERE lower(p.proname) IN (#{quoted}) AND p.provolatile = 'v' AND (lower(p.proname) NOT IN (#{listed}) " \
+            "OR (p.pronamespace <> 'pg_catalog'::regnamespace AND l.lanname NOT IN ('c', 'internal')))"
           ).first
         end
       end

data/lib/rails_ai_context/tools/get_conventions.rb

@@ -284,19 +284,19 @@ module RailsAiContext
 
         if auth_checks.any? || auth_denials.any?
           sections << "" << "### Authorization"
-          auth_checks.uniq.first(5).each { |c| sections << "- Check: `#{c}`" }
-          auth_denials.uniq.first(5).each { |d| sections << "- Deny: #{d}" }
+          sections.concat(capped_list(auth_checks.uniq) { |c| "- Check: `#{c}`" })
+          sections.concat(capped_list(auth_denials.uniq) { |d| "- Deny: #{d}" })
         end
 
         if flash_notices.any? || flash_alerts.any?
           sections << "" << "### Flash Messages"
-          flash_notices.uniq.first(5).each { |n| sections << "- Success: notice: \"#{n}\"" }
-          flash_alerts.uniq.first(5).each { |a| sections << "- Failure: alert: \"#{a}\"" }
+          sections.concat(capped_list(flash_notices.uniq) { |n| "- Success: notice: \"#{n}\"" })
+          sections.concat(capped_list(flash_alerts.uniq) { |a| "- Failure: alert: \"#{a}\"" })
         end
 
         if not_found_patterns.any?
           sections << "" << "### Error Handling"
-          not_found_patterns.first(5).each { |p| sections << "- Not found: #{p}" }
+          sections.concat(capped_list(not_found_patterns) { |p| "- Not found: #{p}" })
         end
 
         if create_flows.any?
@@ -402,6 +402,11 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, [], label: "detect_app_patterns")
       end
 
+      private_class_method def self.capped_list(items, cap = 5, &line)
+        shown = items.first(cap).map(&line)
+        items.size > cap ? shown << "- _...and #{items.size - cap} more._" : shown
+      end
+
       private_class_method def self.detect_locale_info
         info = []
         locales_dir = rails_app.root.join("config", "locales").to_s

data/lib/rails_ai_context/tools/get_schema.rb

@@ -81,6 +81,8 @@ module RailsAiContext
               # `order_comments` are the same request.
               declared = table_key.to_s.underscore
               if declared_not_connected(schema).include?(declared)
+                return text_response("Table '#{declared}' is declared in #{dump_name(schema)}. #{shared_dump_note(schema, [ declared ])}") if schema[:shared_dump]
+
                 return text_response(
                   "Table '#{declared}' is declared in #{schema[:declared_in] || "db/schema.rb"} and missing from the connected database. " \
                   "#{pending_for_table(schema, declared)}" \
@@ -401,6 +403,25 @@ module RailsAiContext
         schema[:declared_in] || schema[:note].to_s[/\AParsed from (\S+)/, 1] || "db/schema.rb"
       end
 
+      # A table the shared dump declares that the connected database lacks may be the other database's,
+      # so it is no sign the connected one is behind.
+      private_class_method def self.shared_dump_lines(schema)
+        absent = schema[:connected_tables]&.zero? ? (schema[:tables] || {}).keys.map(&:to_s) : declared_not_connected(schema)
+        return [] if absent.empty?
+
+        [ "_#{shared_dump_note(schema, absent)}_" ]
+      end
+
+      private_class_method def self.shared_dump_note(schema, absent)
+        shared = schema[:shared_dump]
+        "#{shared[:primary]} and #{shared[:other]} both dump to #{dump_name(schema)}, so it may describe #{shared[:other]}. " \
+          "Not in #{shared[:primary]}: #{names_phrase(absent)}."
+      end
+
+      private_class_method def self.names_phrase(names)
+        "#{names.sort.first(5).join(', ')}#{" (+#{names.size - 5} more)" if names.size > 5}"
+      end
+
       private_class_method def self.static_source_lines(schema)
         lines = note_lines(schema)
         lines << "**Dialect:** #{schema[:dialect]}" if schema[:dialect] && schema[:dialect] != "unknown"
@@ -409,17 +430,20 @@ module RailsAiContext
         # db/schema.rb, and nothing joined the two: at that migration the app
         # has the table the database is missing.
         missing = declared_not_connected(schema)
-        if missing.any?
-          declared_total = Array(schema[:declared_tables]).size
-          connected_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})
-          lines << "_#{schema[:declared_in] || "db/schema.rb"} declares #{count_phrase(declared_total, "table")}; the connected database has " \
-                   "#{connected_total}. Missing: #{missing.sort.first(5).join(', ')}" \
-                   "#{missing.size > 5 ? " (+#{missing.size - 5} more)" : ""}. Run `rails db:migrate`._"
-        end
-        # A database that holds none of the tables the dump lists is created
-        # but not migrated, and the listing above is the dump's.
-        if schema[:connected_tables]&.zero? && (declared_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})).positive?
-          lines << "_#{dump_name(schema)} declares #{count_phrase(declared_total, "table")}; the connected database has none of them. Run `rails db:migrate`._"
+        if schema[:shared_dump]
+          lines.concat(shared_dump_lines(schema))
+        else
+          if missing.any?
+            declared_total = Array(schema[:declared_tables]).size
+            connected_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})
+            lines << "_#{schema[:declared_in] || "db/schema.rb"} declares #{count_phrase(declared_total, "table")}; the connected database has " \
+                     "#{connected_total}. Missing: #{names_phrase(missing)}. Run `rails db:migrate`._"
+          end
+          # A database that holds none of the tables the dump lists is created
+          # but not migrated, and the listing above is the dump's.
+          if schema[:connected_tables]&.zero? && (declared_total = Introspectors::SchemaConventions.table_count(schema[:tables] || {})).positive?
+            lines << "_#{dump_name(schema)} declares #{count_phrase(declared_total, "table")}; the connected database has none of them. Run `rails db:migrate`._"
+          end
         end
         if schema[:pending_unknown]
           lines << "**Pending migrations:** not known: #{schema[:pending_unknown]}"

data/lib/rails_ai_context/tools/query.rb

@@ -198,10 +198,11 @@ module RailsAiContext
         # a parser still reads the block); the unbounded note stays off CSV.
         cut = !schema_metadata && result.respond_to?(:truncated) && result.truncated
         truncation = cut ? truncation_note([ row_limit, HARD_ROW_CAP ].min, format) : ""
+        settings = settings_note(family.own_settings(connection, SqlGate.settings_read(sql, family, result.rows)), format)
         output = if format == "csv"
-          format_csv(redacted) + truncation
+          format_csv(redacted) + truncation + settings
         else
-          (definition ? format_definition(redacted) : format_table(redacted)) + truncation + unbounded_note(result)
+          (definition ? format_definition(redacted) : format_table(redacted)) + truncation + settings + unbounded_note(result)
         end
 
         text_response(output)
@@ -230,6 +231,15 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, "", label: "held_elsewhere")
       end
 
+      # A statement runs with settings rails_query sets for it, which a statement that reads them answers.
+      private_class_method def self.settings_note(own, format)
+        return "" if own.empty?
+
+        note = "#{own.keys.join(" and ")} here #{own.size > 1 ? "are the values" : "is the value"} rails_query sets for each " \
+          "statement it runs. The session's own: #{own.map { |name, value| "#{name} #{value}" }.join(", ")}."
+        format == "csv" ? "\n\n#{note}" : "\n\n_#{note}_"
+      end
+
       private_class_method def self.unbounded_note(result)
         result.respond_to?(:unbounded) && result.unbounded ? UNBOUNDED_SQLITE_NOTE : ""
       end

data/lib/rails_ai_context/tools/runtime_info.rb

@@ -370,8 +370,21 @@ module RailsAiContext
           end
           lines << "**Adapter:** #{adapter_name}"
 
-          # Sidekiq stats (if available)
-          if defined?(Sidekiq)
+          sidekiq_adapter = adapter_name == "sidekiq" && defined?(Sidekiq)
+          unless sidekiq_adapter
+            if adapter_name.start_with?("not ")
+              lines << "_Queue stats unavailable: no queue adapter detected._"
+            else
+              # The adapter's name says the app has a queue backend, one the tool reads no stats from.
+              lines << "_Live queue stats are only implemented for Sidekiq; this app uses the #{adapter_name} adapter._"
+            end
+          end
+
+          # Sidekiq's counts are the app's jobs under its adapter, else only its own Sidekiq::Job workers.
+          if sidekiq_adapter || (defined?(Sidekiq) && Payload.workers(cached_context).any?)
+            unless sidekiq_adapter
+              lines.push("", "### Sidekiq", "_Counts for the Sidekiq workers the app runs outside Active Job; its #{adapter_name} jobs are not in them._")
+            end
             begin
               require "sidekiq/api"
               stats = Sidekiq::Stats.new
@@ -396,14 +409,6 @@ module RailsAiContext
             rescue => e
               lines << "_Sidekiq stats error: #{e.message}_"
             end
-          else
-            # Name the adapter the app actually uses so "no stats" reads as a
-            # tool limitation, not as the app having no queue backend.
-            if adapter_name.start_with?("not ")
-              lines << "_Queue stats unavailable: no queue adapter detected._"
-            else
-              lines << "_Live queue stats are only implemented for Sidekiq; this app uses the #{adapter_name} adapter._"
-            end
           end
 
           lines << ""

data/lib/rails_ai_context/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.35.2
+  version: 5.36.1
 platform: ruby
 authors:
 - crisnahine
@@ -223,18 +223,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
-- ".ruby-version"
-- AGENTS.md
 - CHANGELOG.md
-- CLAUDE.md
-- CODE_OF_CONDUCT.md
-- CONTEXT.md
 - CONTRIBUTING.md
 - LICENSE
 - README.md
-- Rakefile
 - SECURITY.md
 - app/controllers/rails_ai_context/mcp_controller.rb
 - config/routes.rb
@@ -249,27 +241,14 @@ files:
 - docs/PROMPTS.md
 - docs/QUICKSTART.md
 - docs/RECIPES.md
-- docs/RELEASING.md
 - docs/SECURITY.md
 - docs/SETUP.md
 - docs/STANDALONE.md
 - docs/TOOLS.md
 - docs/TROUBLESHOOTING.md
-- docs/_config.yml
-- docs/_includes/head-custom.html
-- docs/adr/0001-own-listener-registration.md
-- docs/adr/0002-static-tier-declared-not-detected.md
-- docs/adr/0003-shared-tool-cache-semantics.md
-- docs/adr/0004-install-e2e-stays-example-rich.md
 - docs/adr/0005-workspace-mcp-entries.md
 - docs/adr/0006-strong-params-resolve-as-ruby-runs.md
 - docs/adr/0007-every-install-question-has-a-flag.md
-- docs/adr/0008-query-runs-only-where-it-can-guard.md
-- docs/adr/0009-dbhub-shapes-in-ruby.md
-- docs/adr/0010-one-config-tool-with-sections.md
-- docs/agents/domain.md
-- docs/agents/issue-tracker.md
-- docs/agents/triage-labels.md
 - docs/index.md
 - exe/rails-ai-context
 - lib/generators/rails_ai_context/install/install_generator.rb
@@ -585,7 +564,6 @@ files:
 - lib/rails_ai_context/vfs.rb
 - lib/rails_ai_context/view_file.rb
 - lib/rails_ai_context/watcher.rb
-- server.json
 homepage: https://github.com/crisnahine/rails-ai-context
 licenses:
 - MIT

data/.rspec

@@ -1,3 +0,0 @@
---require spec_helper
---format documentation
---color

data/.rubocop.yml

@@ -1,16 +0,0 @@
-inherit_gem:
-  rubocop-rails-omakase: rubocop.yml
-
-AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable
-  Exclude:
-    - "spec/fixtures/**/*"
-    - "vendor/**/*"
-
-Style/Documentation:
-  Enabled: false
-
-# rubocop-rails-omakase disables the whole Metrics department. Setting Max on a
-# disabled cop does not re-enable it, so size limits here would enforce nothing.
-# Turning it on would need ~40 existing files brought under the limit first.

data/.ruby-version

@@ -1 +0,0 @@
-3.4.9

data/AGENTS.md

@@ -1,15 +0,0 @@
-# rails-ai-context
-
-## Agent skills
-
-### Issue tracker
-
-Issues live as GitHub issues on `crisnahine/rails-ai-context`, driven with the `gh` CLI. See `docs/agents/issue-tracker.md`.
-
-### Triage labels
-
-The five canonical roles, each label string equal to its name (`needs-triage`, `needs-info`, `ready-for-agent`, `ready-for-human`, `wontfix`). See `docs/agents/triage-labels.md`.
-
-### Domain docs
-
-Single-context: `CONTEXT.md` and `docs/adr/` at the repo root. See `docs/agents/domain.md`.

data/CLAUDE.md

@@ -1,3 +0,0 @@
-# rails-ai-context
-
-Project instructions live in `AGENTS.md`, which is committed and shared. Read it.

data/CODE_OF_CONDUCT.md

@@ -1,44 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, caste, color, religion, or sexual
-identity and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior:
-
-* The use of sexualized language or imagery, and sexual attention or advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the project maintainer at **crisjosephnahine@gmail.com**.
-
-All complaints will be reviewed and investigated promptly and fairly.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org),
-version 2.1, available at
-[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).