infotable 1.5.0 → 1.6.0

data/config/locales/it.yml

@@ -0,0 +1,126 @@
+it:
+  infotable:
+    table:
+      buttons:
+        export_csv: "Esporta CSV"
+        filters: "Filtri"
+        exporting: "Esportazione..."
+        refresh: "Aggiorna"
+        columns: "Colonne"
+      sort_hint: "Clicca per ordinare, Maiusc+clic aggiunge una colonna all'ordinamento"
+      loading:
+        initial: "Caricamento dati..."
+        more_items: "Caricamento di altri elementi..."
+        all_loaded: "Tutti gli elementi sono stati caricati"
+      resize_column: "ridimensiona colonna"
+      empty_state:
+        title: "Nessun dato trovato"
+        description: "Aggiungi dei record per vederli qui."
+        filtered_title: "Nessuna riga corrisponde ai filtri"
+        filtered_description: "Rimuovi un filtro o cerca qualcos'altro."
+
+    drawer:
+      label: "Filtri e colonne"
+      panel_title:
+        customize_columns: "Personalizza colonne"
+        filters: "Filtri"
+        columns: "Colonne"
+      tabs:
+        filters: "Filtri"
+        columns: "Colonne"
+
+    columns:
+      instructions: "Trascina per riordinare, fissa le colonne e mostra/nascondi:"
+      pin:
+        left: "Fissa a sinistra"
+        right: "Fissa a destra"
+      actions:
+        select_all: "Seleziona tutto"
+        deselect_all: "Deseleziona tutto"
+        reset_to_defaults: "🔄 Ripristina predefiniti"
+
+    filters:
+      actions:
+        clear_all: "Cancella tutto"
+        apply_filters: "Applica filtri"
+      clear_filter: "Cancella questo filtro"
+      active:
+        search: "Ricerca: «%{query}»"
+        remove: "Rimuovi il filtro %{filter}"
+        clear_all: "Cancella tutti i filtri"
+      from: "Da"
+      to: "A"
+      min: "Min"
+      max: "Max"
+      enter_value: "Inserisci un valore..."
+      all: "Tutti"
+      multi_select_hint: "Tieni premuto Ctrl/Cmd per selezionarne più di uno"
+      options_truncated: "Mostrate le prime %{shown} opzioni su %{total}"
+      boolean:
+        "true": "Vero"
+        "false": "Falso"
+        empty: "Vuoto"
+        not_empty: "Non vuoto"
+      text_ops:
+        contains: "Contiene"
+        exact: "Corrispondenza esatta"
+        not_contain: "Non contiene"
+        starts_with: "Inizia con"
+        ends_with: "Finisce con"
+        is_empty: "È vuoto"
+        is_not_empty: "Non è vuoto"
+      range_ops:
+        between: "Tra"
+      number_ops:
+        eq: "Uguale a"
+        neq: "Diverso da"
+        gt: "Maggiore di"
+        gte: "Maggiore o uguale a"
+        lt: "Minore di"
+        lte: "Minore o uguale a"
+      date_ops:
+        "on": "Il"
+        before: "Prima del"
+        after: "Dopo il"
+
+    formatters:
+      ago: "%{time} fa"
+      date:
+        short: "%d %b %Y"
+        long: "%d %B %Y"
+        time: "%H:%M"
+        datetime: "%d %b %Y %H:%M"
+      action: "Azione"
+      boolean:
+        "true": "Sì"
+        "false": "No"
+      duration:
+        short:
+          d: "%{count} g"
+          h: "%{count} h"
+          m: "%{count} min"
+          s: "%{count} s"
+        long:
+          d: { one: "%{count} giorno", few: "%{count} giorni", many: "%{count} giorni", other: "%{count} giorni" }
+          h: { one: "%{count} ora", few: "%{count} ore", many: "%{count} ore", other: "%{count} ore" }
+          m: { one: "%{count} minuto", few: "%{count} minuti", many: "%{count} minuti", other: "%{count} minuti" }
+          s: { one: "%{count} secondo", few: "%{count} secondi", many: "%{count} secondi", other: "%{count} secondi" }
+
+    batch:
+      selected: "%{count} selezionati"
+      clear: "Cancella selezione"
+      select_all: "Seleziona tutte le righe"
+      select_row: "Seleziona riga"
+      select_all_matching: "Seleziona tutti i %{count} risultati"
+      truncated: "Sono selezionate solo le prime %{max} righe"
+
+    search:
+      placeholder: "Cerca..."
+      label: "Cerca nella tabella"
+
+    pagination:
+      summary_html: "Visualizzazione da %{from} a %{to} di %{total} risultati"
+      summary_no_total_html: "Visualizzazione da %{from} a %{to}"
+      rows_per_page: "Righe per pagina:"
+      previous: "Precedente"
+      next: "Successivo"

data/config/locales/pl.yml

@@ -85,10 +85,26 @@ pl:
 
     formatters:
       ago: "%{time} temu"
+      date:
+        short: "%d %b %Y"
+        long: "%d %B %Y"
+        time: "%H:%M"
+        datetime: "%d %b %Y %H:%M"
       action: "Akcja"
       boolean:
         "true": "Tak"
         "false": "Nie"
+      duration:
+        short:
+          d: "%{count} d"
+          h: "%{count} godz."
+          m: "%{count} min"
+          s: "%{count} s"
+        long:
+          d: { one: "%{count} dzień", few: "%{count} dni", many: "%{count} dni", other: "%{count} dni" }
+          h: { one: "%{count} godzina", few: "%{count} godziny", many: "%{count} godzin", other: "%{count} godzin" }
+          m: { one: "%{count} minuta", few: "%{count} minuty", many: "%{count} minut", other: "%{count} minut" }
+          s: { one: "%{count} sekunda", few: "%{count} sekundy", many: "%{count} sekund", other: "%{count} sekund" }
 
     batch:
       selected: "Zaznaczono: %{count}"
@@ -103,10 +119,8 @@ pl:
       label: "Szukaj w tabeli"
 
     pagination:
-      showing: "Wyświetlanie"
-      to: "do"
-      of: "z"
-      results: "wyników"
+      summary_html: "Wyświetlanie %{from} do %{to} z %{total} wyników"
+      summary_no_total_html: "Wyświetlanie %{from} do %{to}"
       rows_per_page: "Wierszy na stronę:"
       previous: "Poprzednia"
       next: "Następna"

data/exe/infotable-mcp

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# MCP server (stdio) that lets an AI assistant create InfoTable tables in the host app:
+#   bundle exec infotable-mcp
+# Run it from the Rails app's root, see "MCP server" in the README.
+require "bundler/setup"
+
+environment = File.expand_path("config/environment", Dir.pwd)
+abort "infotable-mcp: run it from the root of a Rails app (no config/environment.rb in #{Dir.pwd})" unless File.exist?("#{environment}.rb")
+
+require environment
+require "infotable/mcp"
+
+Infotable::Mcp::Server.run

data/lib/generators/infotable/table/table_generator.rb

@@ -9,6 +9,14 @@ module Infotable
 
       class_option :only, type: :array, default: [], desc: "Only these columns"
       class_option :skip, type: :array, default: [], desc: "Leave these columns out"
+      class_option :per_page, type: :numeric, default: 25, desc: "Rows per page"
+      class_option :sort, type: :string, desc: "Default sort as column:direction, e.g. created_at:desc"
+      class_option :toolbar, type: :string, desc: "Toolbar mode: header or rail"
+      class_option :row_click, type: :boolean, default: false, desc: "Clicking a row opens its row_link"
+      class_option :infinite_scroll, type: :boolean, default: false, desc: "Infinite scroll instead of pages"
+      class_option :countless, type: :boolean, default: false, desc: "Skip the total count (big tables)"
+      class_option :checkbox, type: :boolean, default: false, desc: "Row selection column"
+      class_option :authorize, type: :string, desc: "Ruby expression over `controller` that decides who sees the table"
 
       # Attributes that must never end up in a table by accident
       SENSITIVE = /password|digest|token|secret|otp|encrypted/
@@ -82,9 +90,23 @@ module Infotable
         @model.reflect_on_all_associations(:belongs_to).map(&:name)
       end
 
+      # Table-level settings chosen with the options above, one DSL line each
+      def setting_lines
+        lines = []
+        lines << "toolbar :#{options[:toolbar]}" if options[:toolbar].present?
+        lines << "infinite_scroll true" if options[:infinite_scroll]
+        lines << "countless" if options[:countless]
+        lines << "checkbox_column" if options[:checkbox]
+        lines << "row_click" if options[:row_click]
+        lines
+      end
+
       def default_sort_line
         names = column_specs.map { _1[:name] }
-        if names.include?("created_at")
+        if options[:sort].present?
+          column, direction = options[:sort].split(":")
+          "default_sort :#{column}, :#{direction == 'desc' ? 'desc' : 'asc'}"
+        elsif names.include?("created_at")
           "default_sort :created_at, :desc"
         elsif names.any?
           "default_sort :#{names.first}, :asc"

data/lib/generators/infotable/table/templates/table.rb.tt

@@ -19,8 +19,15 @@ class <%= table_class_name %> < Infotable::Base
 <% end -%>
 <% end -%>
 
-  per_page 25
+  per_page <%= options[:per_page] %>
 <% if default_sort_line %>
   <%= default_sort_line %>
 <% end -%>
+<% setting_lines.each do |line| -%>
+  <%= line %>
+<% end -%>
+<% if options[:authorize].present? %>
+
+  authorize { |controller| <%= options[:authorize] %> }
+<% end -%>
 end

data/lib/infotable/base.rb

@@ -1,5 +1,10 @@
 module Infotable
   class Base
+    # Options column accepts; anything else is logged as a probable typo
+    COLUMN_OPTIONS = %i[label type sortable searchable filterable visible exportable pinned virtual virtual_sql
+                        sql sort_sql value includes formatter formatter_options actions filter_type filter_options
+                        filter_options_cache filter_options_limit filter_multi_select width].freeze
+
     class << self
       attr_accessor :table_columns, :table_query, :table_query_sql, :pagination_settings, :sort_settings, :height_settings, :infinite_scroll_settings, :row_link_settings, :row_attr_settings, :slim_rows_settings, :row_size_settings, :filters_button_settings, :display_settings, :nil_value_settings, :empty_value_settings, :table_authorize, :checkbox_settings, :batch_action_list, :countless_setting, :url_state_setting, :resizable_columns_setting
 
@@ -171,10 +176,6 @@ module Infotable
       end
 
       # Define a column
-      COLUMN_OPTIONS = %i[label type sortable searchable filterable visible exportable pinned virtual virtual_sql
-                          sql sort_sql value includes formatter formatter_options actions filter_type filter_options
-                          filter_options_cache filter_options_limit filter_multi_select width].freeze
-
       def column(name, **options)
         @table_columns ||= []
         unknown = options.keys - COLUMN_OPTIONS

data/lib/infotable/formatters/currency_formatter.rb

@@ -1,21 +1,13 @@
 module Infotable
   module Formatters
+    # formatter: :currency
+    #   formatter_options: { unit: "$", precision: 2, delimiter: ",", separator: "." }
+    # Options you leave out come from I18n (`number.currency.format`) for the current locale.
     class CurrencyFormatter < BaseFormatter
       def format(value, record, options = {})
         return "" if value.blank?
 
-        unit = options[:unit] || "$"
-        precision = options[:precision] || 2
-        delimiter = options[:delimiter] || ","
-        separator = options[:separator] || "."
-
-        number_to_currency(
-          value,
-          unit: unit,
-          precision: precision,
-          delimiter: delimiter,
-          separator: separator
-        )
+        number_to_currency(value, options.slice(:unit, :precision, :delimiter, :separator))
       end
     end
   end

data/lib/infotable/formatters/date_formatter.rb

@@ -10,16 +10,10 @@ module Infotable
         format = options[:format] || :default
 
         case format
-        when :short
-          value.strftime("%b %d, %Y")
-        when :long
-          value.strftime("%B %d, %Y")
-        when :time
-          value.strftime("%I:%M %p")
-        when :datetime
-          value.strftime("%b %d, %Y %I:%M %p")
+        when :short, :long, :time, :datetime
+          view_context.l(value, format: view_context.t("infotable.formatters.date.#{format}"))
         when :relative
-          time_ago_in_words(value)
+          view_context.content_tag(:span, time_ago_in_words(value), title: value.strftime("%Y-%m-%d %H:%M"))
         when :dot_date
           value.strftime("%d.%m.%Y")
         when :default

data/lib/infotable/formatters/duration_formatter.rb

@@ -0,0 +1,51 @@
+module Infotable
+  module Formatters
+    # formatter: :duration
+    # Seconds as "1h 05m" (:short, default) or "1 hour 5 minutes" (:long).
+    #   formatter_options: { format: :short, parts: 2 }   # parts: how many units to show, from the largest
+    class DurationFormatter < BaseFormatter
+      UNITS = { d: 86_400, h: 3600, m: 60, s: 1 }.freeze
+
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+
+        seconds = Float(value.to_s, exception: false)
+        return value.to_s if seconds.nil? || seconds.negative?
+
+        parts = split(seconds.round).first(options.fetch(:parts, 2))
+        parts = [ [ :s, 0 ] ] if parts.empty?
+        options[:format].to_s == "long" ? long(parts) : short(parts)
+      end
+
+      private
+
+      # [[:h, 1], [:m, 5]]; units with nothing in them are left out
+      def split(seconds)
+        UNITS.filter_map do |unit, size|
+          count, seconds = seconds.divmod(size)
+          [ unit, count ] if count.positive?
+        end
+      end
+
+      def short(parts)
+        parts.each_with_index.map do |(unit, count), index|
+          number = index.zero? ? count.to_s : count.to_s.rjust(2, "0")
+          view_context.t("infotable.formatters.duration.short.#{unit}", count: number)
+        end.join(" ")
+      end
+
+      def long(parts)
+        parts.map { |unit, count| view_context.t("infotable.formatters.duration.long.#{unit}.#{plural_key(count)}", count: count) }.join(" ")
+      end
+
+      # The key is picked here, so Polish (1 / 2-4 / 5+) is right without rails-i18n's pluralization rules
+      def plural_key(count)
+        return count == 1 ? :one : :other unless I18n.locale.to_s == "pl"
+        return :one if count == 1
+        return :few if (2..4).cover?(count % 10) && !(12..14).cover?(count % 100)
+
+        :many
+      end
+    end
+  end
+end

data/lib/infotable/formatters/filesize_formatter.rb

@@ -0,0 +1,14 @@
+module Infotable
+  module Formatters
+    # formatter: :filesize
+    # Bytes as a human size: 1536 => "1.5 KB". `formatter_options: { precision: 2 }` (significant digits)
+    class FilesizeFormatter < BaseFormatter
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+        return value.to_s if Float(value.to_s, exception: false).nil?
+
+        view_context.number_to_human_size(value, precision: options.fetch(:precision, 2), strip_insignificant_zeros: true)
+      end
+    end
+  end
+end

data/lib/infotable/formatters/image_formatter.rb

@@ -0,0 +1,31 @@
+module Infotable
+  module Formatters
+    # formatter: :image
+    # A square thumbnail (use :avatar for round pictures); the value is the image URL.
+    #   formatter_options: {
+    #     size: :md,                        # :sm (32px), :md (48px), :lg (64px)
+    #     alt: ->(record) { record.name },  # alt text, a String or a Proc
+    #     link: true                        # open the full image in a new tab
+    #   }
+    class ImageFormatter < BaseFormatter
+      SIZES = { sm: "h-8 w-8", md: "h-12 w-12", lg: "h-16 w-16" }.freeze
+
+      def format(value, record, options = {})
+        return "" unless image_url?(value)
+
+        alt = options[:alt].is_a?(Proc) ? view_context.instance_exec(record, &options[:alt]) : options[:alt]
+        size = SIZES.fetch((options[:size] || :md).to_sym, SIZES[:md])
+        image = tag.img(src: value.to_s, alt: alt.to_s, loading: "lazy", class: "#{size} rounded-md object-cover flex-none")
+        return image unless options[:link]
+
+        link_to(image, value.to_s, target: "_blank", rel: "noopener noreferrer")
+      end
+
+      private
+
+      def image_url?(value)
+        LinkFormatter.safe_url?(value) && value.to_s.match?(%r{\A(https?:)?//|\A/})
+      end
+    end
+  end
+end

data/lib/infotable/formatters/number_formatter.rb

@@ -0,0 +1,46 @@
+module Infotable
+  module Formatters
+    # formatter: :number
+    #   formatter_options: {
+    #     precision: 2,       # decimals; without it the number is shown as it is
+    #     delimiter: ",",     # thousands separator, default ","
+    #     separator: ".",     # decimal separator, default "."
+    #     unit: "ms",         # appended after the number
+    #     compact: true,      # 1.2k, 3.4M, 5B (precision defaults to 1)
+    #     zero: "-"           # shown instead of 0
+    #   }
+    class NumberFormatter < BaseFormatter
+      COMPACT_STEPS = [ [ 1_000_000_000, "B" ], [ 1_000_000, "M" ], [ 1_000, "k" ] ].freeze
+
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+
+        number = Float(value.to_s, exception: false)
+        return value.to_s if number.nil?
+        return options[:zero].to_s if options.key?(:zero) && number.zero?
+
+        text = options[:compact] ? compact(value, number, options) : plain(value, options)
+        text = "#{text} #{options[:unit]}" if options[:unit].present?
+        content_tag(:span, text, class: "tabular-nums")
+      end
+
+      private
+
+      def plain(value, options)
+        delimiter = options.fetch(:delimiter, ",")
+        separator = options.fetch(:separator, ".")
+        return view_context.number_with_delimiter(value, delimiter: delimiter, separator: separator) unless options[:precision]
+
+        view_context.number_with_precision(value, precision: options[:precision], delimiter: delimiter, separator: separator)
+      end
+
+      def compact(value, number, options)
+        divisor, suffix = COMPACT_STEPS.find { |step, _| number.abs >= step }
+        return plain(value, options) unless divisor
+
+        view_context.number_with_precision(number / divisor, precision: options.fetch(:precision, 1),
+                                           separator: options.fetch(:separator, "."), strip_insignificant_zeros: true) + suffix
+      end
+    end
+  end
+end

data/lib/infotable/formatters/tags_formatter.rb

@@ -0,0 +1,44 @@
+module Infotable
+  module Formatters
+    # formatter: :tags (alias :list)
+    # The value is an Array, a relation or a comma separated string; every item becomes a small badge.
+    #   formatter_options: {
+    #     limit: 3,                        # show this many, then "+N" (the rest is in its tooltip)
+    #     label: ->(item) { item.name },   # text of an item, defaults to item.to_s
+    #     colors: { "admin" => "red" },    # item => badge colour, as in :badge (default gray)
+    #     separator: ", "                  # plain text joined with this instead of badges
+    #   }
+    class TagsFormatter < BaseFormatter
+      def format(value, record, options = {})
+        labels = items(value).map { label_for(_1, options) }.reject(&:blank?)
+        return "" if labels.empty?
+
+        return safe_join(labels, options[:separator].to_s) if options[:separator]
+
+        limit = options[:limit]
+        shown, rest = limit ? [ labels.first(limit), labels.drop(limit) ] : [ labels, [] ]
+        badges = shown.map { badge(_1, options) }
+        badges << content_tag(:span, "+#{rest.size}", title: rest.join(", "), class: "text-xs text-gray-500 dark:text-gray-400") if rest.any?
+        content_tag(:div, safe_join(badges), class: "flex flex-wrap items-center gap-1")
+      end
+
+      private
+
+      def items(value)
+        return [] if value.nil?
+        return value.split(",").map(&:strip) if value.is_a?(String)
+
+        value.respond_to?(:to_a) ? value.to_a : [ value ]
+      end
+
+      def label_for(item, options)
+        label = options[:label].is_a?(Proc) ? view_context.instance_exec(item, &options[:label]) : item
+        label.to_s
+      end
+
+      def badge(text, options)
+        BadgeFormatter.new(view_context).format(text, nil, label: text, size: :small, colors: options[:colors])
+      end
+    end
+  end
+end

data/lib/infotable/formatters/truncate_formatter.rb

@@ -0,0 +1,19 @@
+module Infotable
+  module Formatters
+    # formatter: :truncate
+    # Long text cut to `length` characters; the full text stays in the cell's tooltip.
+    #   formatter_options: { length: 60, omission: "…" }
+    class TruncateFormatter < BaseFormatter
+      def format(value, record, options = {})
+        return "" if value.blank?
+
+        text = value.to_s
+        length = options.fetch(:length, 60)
+        return text if text.length <= length
+
+        shortened = view_context.truncate(text, length: length, omission: options.fetch(:omission, "…"))
+        content_tag(:span, shortened, title: text)
+      end
+    end
+  end
+end

data/lib/infotable/mcp/introspection.rb

@@ -0,0 +1,94 @@
+require "generators/infotable/table/table_generator"
+
+module Infotable
+  module Mcp
+    # What the host app looks like: models and their columns, tables that exist, the DSL of this gem version.
+    module Introspection
+      module_function
+
+      def models
+        Rails.application.eager_load!
+        ActiveRecord::Base.descendants.reject { _1.abstract_class? || _1.name.nil? || !_1.table_exists? }.sort_by(&:name).map { describe_model(_1) }
+      end
+
+      def describe_model(model)
+        {
+          name: model.name,
+          table: model.table_name,
+          columns: model.columns.to_h { [ _1.name, _1.type.to_s ] },
+          enums: model.defined_enums.transform_values(&:keys),
+          associations: model.reflect_on_all_associations.map { { name: _1.name, kind: _1.macro, model: _1.options[:class_name] || _1.name.to_s.classify } }
+        }
+      end
+
+      def tables
+        Rails.application.eager_load!
+        Infotable::Base.descendants.reject { _1.name.nil? }.sort_by(&:name).map { describe_table(_1) }
+      end
+
+      def describe_table(table)
+        {
+          class: table.name,
+          model: (table.base_query.model.name rescue nil),
+          columns: table.columns.map { |col| col.slice(:name, :type, :sortable, :searchable, :filterable, :filter_type, :visible, :pinned).compact },
+          per_page: table.pagination_settings[:per_page],
+          default_sort: table.sort_settings.presence,
+          toolbar: table.toolbar_mode,
+          batch_actions: table.batch_action_list.map { _1[:name] },
+          row_click: table.row_click?,
+          infinite_scroll: table.infinite_scroll_enabled?,
+          countless: table.countless?,
+          no_authorize_block: table.table_authorize.nil?
+        }
+      end
+
+      # The DSL as this gem version knows it, read from the code so it cannot drift from the docs
+      def dsl
+        {
+          version: Infotable::VERSION,
+          column_options: Infotable::Base::COLUMN_OPTIONS,
+          column_types: Infotable::Generators::TableGenerator::TYPE_MAP.values.map { _1[:type] }.uniq + %i[badge currency percent link avatar action],
+          filter_types: %i[text boolean number date select],
+          formatters: Infotable::Formatters.built_in.keys,
+          toolbar_modes: %i[header rail],
+          table_settings: %i[query query_sql per_page per_page_options default_sort infinite_scroll countless url_state resizable_columns
+                             toolbar row_click row_link row_class row_data row_size checkbox_column batch_actions authorize export_columns
+                             table_title table_subtitle table_height nil_value empty_value],
+          batch_action_options: { required: %i[url], optional: %i[label method confirm color], methods: Infotable::BatchActions::METHODS, colors: Infotable::BatchActions::COLORS },
+          generate_table_options: Infotable::Generators::TableGenerator.class_options.keys
+        }
+      end
+
+      # Questions to put to the user before generating a table, each with a default proposed from the model
+      def table_options(model_name)
+        model = model_name.to_s.safe_constantize
+        return nil unless model.is_a?(Class) && model < ActiveRecord::Base
+
+        columns = model.column_names.reject { Infotable::Generators::TableGenerator::SENSITIVE.match?(_1) }
+        enums = model.defined_enums.keys
+        sort = columns.include?("created_at") ? "created_at:desc" : "#{model.primary_key}:asc"
+        belongs_to = model.reflect_on_all_associations(:belongs_to).map(&:name)
+
+        {
+          model: model.name,
+          notes: [
+            ("enum columns (#{enums.join(', ')}) become badges with a select filter" if enums.any?),
+            ("belongs_to #{belongs_to.join(', ')}: generated as a commented hint, a column needs a join" if belongs_to.any?),
+            "foreign keys and sensitive columns (password, token...) are left out"
+          ].compact,
+          questions: [
+            { param: "only", ask: "Which columns?", choices: columns, default: "all of the choices" },
+            { param: "sort", ask: "Default sort (column:direction)?", choices: columns, default: sort },
+            { param: "per_page", ask: "Rows per page?", choices: [ 10, 25, 50, 100 ], default: 25 },
+            { param: "toolbar", ask: "Toolbar: header bar or slim rail?", choices: %w[header rail], default: "header" },
+            { param: "checkbox", ask: "Row selection column?", default: false },
+            { param: "row_click", ask: "Clicking a row opens it (needs row_link)?", default: false },
+            { param: "infinite_scroll", ask: "Infinite scroll instead of pages?", default: false },
+            { param: "countless", ask: "Skip the total count (tables over ~1M rows)?", default: false },
+            { param: "authorize", ask: "Who may see the table? A Ruby expression over `controller`", default: "controller.current_user.present?" }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/infotable/mcp/server.rb

@@ -0,0 +1,26 @@
+module Infotable
+  module Mcp
+    module Server
+      TOOLS = [ ListModels, ListTables, DescribeDsl, TableOptions, GenerateTable, ValidateTable ].freeze
+
+      module_function
+
+      def build
+        readme = ::MCP::Resource.new(uri: "infotable://readme", name: "infotable-readme", title: "InfoTable README",
+                                     description: "Full documentation of the table DSL", mime_type: "text/markdown")
+        server = ::MCP::Server.new(
+          name: "infotable", version: Infotable::VERSION, tools: TOOLS, prompts: [ NewTablePrompt ], resources: [ readme ],
+          instructions: "Creates InfoTable tables in this Rails app. Start with list_models and table_options; ask the user for the settings before generate_table."
+        )
+        server.resources_read_handler do |params|
+          [ { uri: params[:uri], mimeType: "text/markdown", text: File.read(Infotable.root.join("README.md")) } ]
+        end
+        server
+      end
+
+      def run
+        ::MCP::Server::Transports::StdioTransport.new(build).open
+      end
+    end
+  end
+end