talk_to_your_app 0.1.0.pre.1

data/lib/talk_to_your_app/plugins/rake/tools/run.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../../../tool"
+
+module TalkToYourApp
+  module Plugins
+    module Rake
+      module Tools
+        # Runs a single allow-listed rake task and returns its status and output
+        # as JSON. The task must be on the plugin's `allowed:` list; anything
+        # else is refused without executing. The task runs in a subprocess
+        # (`bundle exec rake`), so it cannot inject shell commands and its real
+        # exit status is captured.
+        class Run < TalkToYourApp::Tool
+          Result = Struct.new(:stdout, :stderr, :exit_code, keyword_init: true)
+
+          name        "rake.run"
+          description "Run an allow-listed rake task and return its status and output."
+          argument    :task, :string, required: true, description: "Rake task name (must be allow-listed), e.g. \"stats\"."
+          argument    :args, :array, description: "Positional task arguments, e.g. [\"42\"] for task[42]."
+
+          def call(args, _ctx)
+            task = args[:task].to_s
+            unless TalkToYourApp::Plugins::Rake.allowed?(task)
+              return error("Rake task #{task.inspect} is not allowed. Allowed tasks: #{TalkToYourApp::Plugins::Rake.allowed_tasks.inspect}.")
+            end
+
+            result = self.class.run_task(task, Array(args[:args]).map(&:to_s))
+            json(
+              task: task,
+              status: result.exit_code.zero? ? "success" : "error",
+              exit_code: result.exit_code,
+              output: result.stdout.strip,
+              error: (result.stderr.strip.empty? ? nil : result.stderr.strip),
+            )
+          rescue StandardError => e
+            error("Failed to run rake #{args[:task]}: #{e.class}: #{e.message}")
+          end
+
+          # Executes `bundle exec rake <task>[args]` in the app root. Array argv
+          # (no shell) so task/args cannot inject shell commands.
+          def self.run_task(task, rake_args)
+            invocation = rake_args.empty? ? task : "#{task}[#{rake_args.join(",")}]"
+            stdout, stderr, status = Open3.capture3("bundle", "exec", "rake", invocation, chdir: app_root)
+            Result.new(stdout: stdout, stderr: stderr, exit_code: status.exitstatus || 1)
+          end
+
+          def self.app_root
+            defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.to_s : Dir.pwd
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/railtie.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module TalkToYourApp
+  # Wires the gem into the Rails boot sequence. The headline behavior is the
+  # fail-closed validation initializer: every required piece of configuration is
+  # checked once, at the end of boot, so misconfiguration surfaces at deploy
+  # time rather than on the first MCP request.
+  class Railtie < ::Rails::Railtie
+    # The gem owns two subdirs of app/talk_to_your_app/ and loads them itself
+    # (custom_tools/ files it requires; health/ files define no constant — they
+    # call Health.register). Tell every autoloader to ignore just those two
+    # subdirs before it is set up, so eager loading (production, zeitwerk:check)
+    # doesn't expect constants that aren't there. Anything else a host places
+    # under app/talk_to_your_app/ is left to Zeitwerk to autoload normally.
+    initializer "talk_to_your_app.ignore_app_dir", before: :set_autoload_paths do |app|
+      next unless ::Rails.respond_to?(:autoloaders)
+
+      %w[custom_tools health].each do |subdir|
+        dir = app.root.join(TalkToYourApp::APP_DIR, subdir)
+        ::Rails.autoloaders.each { |loader| loader.ignore(dir) }
+      end
+    end
+
+    # Runs after the host app's config/initializers (where the operator calls
+    # TalkToYourApp.configure) have loaded.
+    initializer "talk_to_your_app.validate", after: :load_config_initializers do
+      config.after_initialize do
+        TalkToYourApp.configuration.logger ||= Rails.logger
+        TalkToYourApp::Railtie.validate_boot!
+      end
+    end
+
+    # Aggregated fail-closed validation. With nothing enabled (the default),
+    # validation is a no-op and the gem boots silently. Later units add auth and
+    # plugin checks.
+    def self.validate_boot!
+      TalkToYourApp::PluginRegistry.validate_enabled!
+      TalkToYourApp::ConnectionRegistry.validate!(TalkToYourApp.required_connections)
+      validate_auth!
+    end
+
+    # At least one auth mechanism must be configured once the endpoint serves
+    # tools. With no plugins enabled (the default) there is nothing to protect,
+    # so the gem still boots cleanly with no configuration at all.
+    def self.validate_auth!
+      return if TalkToYourApp.configuration.enabled_plugins.empty?
+      return if TalkToYourApp.configuration.auth_configured?
+
+      raise ConfigurationError,
+        "talk_to_your_app: no authentication configured. Set `config.api_keys` or `config.basic_auth` " \
+        "in config/initializers/talk_to_your_app.rb (the MCP endpoint must not be exposed unauthenticated)."
+    end
+  end
+end

data/lib/talk_to_your_app/renderers/html_table.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module TalkToYourApp
+  module Renderers
+    # Minimal HTML table renderer — no ActionView dependency. Every value is
+    # HTML-escaped via CGI.escape_html; the output is returned as a plain string
+    # for an MCP text content block and is never marked html_safe. NULL cells
+    # render as empty.
+    module HtmlTable
+      module_function
+
+      def render(columns, rows)
+        head = "<thead><tr>#{columns.map { |c| "<th>#{esc(c)}</th>" }.join}</tr></thead>"
+        body = rows.map do |row|
+          "<tr>#{row.map { |cell| "<td>#{cell.nil? ? "" : esc(cell)}</td>" }.join}</tr>"
+        end.join
+        "<table>#{head}<tbody>#{body}</tbody></table>"
+      end
+
+      def esc(value)
+        CGI.escape_html(value.to_s)
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/tool.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+require_relative "current"
+require_relative "audit_logger"
+
+module TalkToYourApp
+  # Base class for MCP tools. Authors subclass it, declare arguments with the
+  # class-level DSL, and implement `#call(args, ctx)`.
+  #
+  #   class DbQueryTool < TalkToYourApp::Tool
+  #     name        "db.query"
+  #     description "Run a read-only SQL query."
+  #     connection  :replica_readonly
+  #     argument    :sql,    :string, required: true
+  #     argument    :format, :string, enum: %w[json text html], default: "json"
+  #
+  #     def call(args, ctx)
+  #       ctx.connection { |conn| ... }
+  #     end
+  #   end
+  #
+  # A tool compiles down to an `MCP::Tool` subclass via `.to_mcp_tool`; the
+  # argument DSL produces the JSON Schema the SDK validates against.
+  class Tool
+    NOT_SET = Object.new
+    private_constant :NOT_SET
+
+    # The context handed to `#call`. Exposes the request principal and session,
+    # the audit logger, and role-switched database connections.
+    class Context
+      attr_reader :logger
+
+      def initialize(tool_class:, logger: nil)
+        @tool_class = tool_class
+        @logger = logger
+      end
+
+      def principal
+        TalkToYourApp::Current.principal
+      end
+
+      def session_id
+        TalkToYourApp::Current.session_id
+      end
+
+      # Runs the block against a registry connection, switched to its declared
+      # role. With no name, uses the tool's declared `connection`.
+      def connection(name = nil, &block)
+        name ||= @tool_class.connection
+        if name.nil?
+          raise TalkToYourApp::ConfigurationError,
+            "tool #{@tool_class.tool_name.inspect} called ctx.connection without a name and declares no `connection`."
+        end
+        TalkToYourApp::ConnectionRegistry.with(name, &block)
+      end
+    end
+
+    class << self
+      # --- DSL ---------------------------------------------------------------
+
+      # The MCP tool name (e.g. "db.query"). Overrides Class#name as a setter
+      # while preserving it as a reader before one is assigned.
+      def name(value = NOT_SET)
+        if value == NOT_SET
+          defined?(@tool_name) && @tool_name ? @tool_name : super()
+        else
+          @tool_name = value
+        end
+      end
+      alias_method :tool_name, :name
+
+      def description(value = NOT_SET)
+        value == NOT_SET ? @description : (@description = value)
+      end
+
+      def connection(value = NOT_SET)
+        value == NOT_SET ? @connection : (@connection = value)
+      end
+
+      def argument(arg_name, type, required: false, enum: nil, default: nil, description: nil, redact: false, minimum: nil, maximum: nil)
+        arguments[arg_name.to_sym] = {
+          type: type.to_s,
+          required: required,
+          enum: enum,
+          default: default,
+          description: description,
+          redact: redact,
+          minimum: minimum,
+          maximum: maximum,
+        }.compact
+      end
+
+      def arguments
+        @arguments ||= {}
+      end
+
+      # --- Compilation -------------------------------------------------------
+
+      # JSON Schema (object) for the declared arguments.
+      def input_schema_hash
+        properties = arguments.each_with_object({}) do |(arg_name, opts), acc|
+          prop = { type: opts[:type] }
+          prop[:enum] = opts[:enum] if opts[:enum]
+          prop[:description] = opts[:description] if opts[:description]
+          prop[:minimum] = opts[:minimum] if opts[:minimum]
+          prop[:maximum] = opts[:maximum] if opts[:maximum]
+          acc[arg_name] = prop
+        end
+        required = arguments.select { |_, o| o[:required] }.keys.map(&:to_s)
+        schema = { properties: properties }
+        # Draft-04 (the SDK's metaschema) rejects an empty `required` array.
+        schema[:required] = required unless required.empty?
+        schema
+      end
+
+      # The shape used by tests and documentation.
+      def to_mcp_definition
+        { name: tool_name, description: description, input_schema: input_schema_hash }
+      end
+
+      # Builds the MCP::Tool subclass the server registers. Its class-level
+      # `call(**args, server_context:)` bridges to this tool's `#call(args, ctx)`.
+      # plugin_name and log_level are threaded through for the audit logger.
+      def to_mcp_tool(plugin_name: nil, log_level: nil)
+        if tool_name.nil? || tool_name.to_s.empty?
+          raise TalkToYourApp::ConfigurationError,
+            "#{inspect} has no MCP tool name — call `name \"your.tool\"` in the tool class."
+        end
+
+        ttya_tool = self
+        MCP::Tool.define(
+          name: ttya_tool.tool_name,
+          description: ttya_tool.description,
+          input_schema: ttya_tool.input_schema_hash,
+        ) do |server_context: nil, **args|
+          ttya_tool.dispatch(args, plugin_name: plugin_name, log_level: log_level)
+        end
+      end
+
+      # Invocation entry point, wrapped by the audit logger: one log line per
+      # call. Applies argument defaults, runs the tool, and normalizes the return
+      # into an MCP::Tool::Response.
+      def dispatch(args, plugin_name: nil, log_level: nil)
+        AuditLogger.around(tool_class: self, plugin_name: plugin_name, log_level: log_level, params: args) do
+          if TalkToYourApp.configuration.authorized?(TalkToYourApp::Current.principal, tool_name)
+            invoke(args)
+          else
+            MCP::Tool::Response.new(
+              [{ type: "text", text: "Not authorized: principal may not call #{tool_name}." }],
+              error: true,
+            )
+          end
+        end
+      end
+
+      def invoke(args)
+        merged = default_arguments.merge(args)
+        ctx = Context.new(tool_class: self, logger: TalkToYourApp.configuration.logger)
+        normalize_response(new.call(merged, ctx))
+      end
+
+      # Static metadata, computed once per tool class.
+      def default_arguments
+        @default_arguments ||= arguments.each_with_object({}) do |(arg_name, opts), acc|
+          acc[arg_name] = opts[:default] unless opts[:default].nil?
+        end
+      end
+
+      def normalize_response(result)
+        case result
+        when MCP::Tool::Response
+          result
+        when String
+          MCP::Tool::Response.new([{ type: "text", text: result }])
+        else
+          MCP::Tool::Response.new([{ type: "text", text: result.to_json }])
+        end
+      end
+    end
+
+    # Tool authors override this.
+    def call(_args, _ctx)
+      raise NotImplementedError, "#{self.class}#call must be implemented"
+    end
+
+    # --- Response helpers available to subclasses ---------------------------
+
+    private
+
+    def text(string)
+      MCP::Tool::Response.new([{ type: "text", text: string.to_s }])
+    end
+
+    def json(object)
+      MCP::Tool::Response.new([{ type: "text", text: JSON.pretty_generate(object) }])
+    end
+
+    def error(message)
+      MCP::Tool::Response.new([{ type: "text", text: message.to_s }], error: true)
+    end
+  end
+end

data/lib/talk_to_your_app/transport/rails_mount.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "mcp"
+require_relative "../auth/middleware"
+
+module TalkToYourApp
+  module Transport
+    # Builds the Rack application the host app mounts. It assembles an
+    # MCP::Server from the enabled plugins' tools, wraps it in the SDK's
+    # Streamable HTTP transport, and fronts the whole thing with the auth
+    # middleware. The session layer lives entirely in the SDK transport, so a
+    # future stateless flip (2026-07-28 RC) is a one-line change here.
+    module RailsMount
+      module_function
+
+      def build
+        config = TalkToYourApp.configuration
+        server = MCP::Server.new(
+          name: config.server_name,
+          title: config.server_title,
+          version: config.server_version,
+          description: config.server_description,
+          instructions: config.instructions,
+          tools: collect_tools,
+        )
+        transport = MCP::Server::Transports::StreamableHTTPTransport.new(
+          server,
+          enable_json_response: true,
+        )
+        Auth::Middleware.new(transport)
+      end
+
+      # Compiles every enabled plugin's tools into MCP::Tool subclasses, each
+      # audit-wrapped with its plugin name and (optional) per-plugin log level.
+      def collect_tools
+        TalkToYourApp.enabled_plugins.flat_map do |name, plugin_class, _opts|
+          next [] unless plugin_class
+
+          plugin_class.tools.map do |tool_class|
+            tool_class.to_mcp_tool(plugin_name: name, log_level: plugin_class.log_level)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/talk_to_your_app/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TalkToYourApp
+  VERSION = "0.1.0.pre.1"
+end

data/lib/talk_to_your_app.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "talk_to_your_app/version"
+require_relative "talk_to_your_app/configuration"
+require_relative "talk_to_your_app/connection_registry"
+require_relative "talk_to_your_app/current"
+require_relative "talk_to_your_app/audit_logger"
+require_relative "talk_to_your_app/tool"
+require_relative "talk_to_your_app/plugin"
+require_relative "talk_to_your_app/plugin_registry"
+require_relative "talk_to_your_app/transport/rails_mount"
+
+# Rails-native MCP server. See README for the configuration reference.
+module TalkToYourApp
+  # Convention directory for host-app extensions: custom_tools/ holds CustomTool
+  # subclasses, health/ holds health-check files. The railtie tells Zeitwerk to
+  # ignore this tree (health files define no constant; tools we require here), so
+  # the gem loads its files itself via require_app_dir.
+  APP_DIR = "app/talk_to_your_app"
+
+  class << self
+    # Yields the configuration singleton for the host app's initializer.
+    #
+    #   TalkToYourApp.configure do |config|
+    #     config.mount_at = "/mcp"
+    #   end
+    #
+    # Calling this more than once merges into the same object rather than
+    # replacing it.
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Test seam: drop all configuration back to defaults.
+    def reset_configuration!
+      @configuration = Configuration.new
+      @rack_app = nil
+      ConnectionRegistry.reset!
+    end
+
+    # The Rack application to mount in the host app's routes:
+    #
+    #   mount TalkToYourApp.rack_app, at: TalkToYourApp.configuration.mount_at
+    #
+    # Built once from the enabled plugins. reset_configuration! clears it.
+    def rack_app
+      @rack_app ||= Transport::RailsMount.build
+    end
+
+    # Registers a plugin class under a name so it can be enabled in the
+    # initializer. Bundled plugins register themselves on load; plugin authors
+    # call this from their own code.
+    def register_plugin(name, plugin_class)
+      PluginRegistry.register(name, plugin_class)
+    end
+
+    # The enabled plugins as [name, plugin_class, options] triples, in the order
+    # they were enabled. plugin_class is nil if the name was never registered
+    # (validation surfaces that at boot).
+    def enabled_plugins
+      configuration.enabled_plugins.map do |name, opts|
+        [name, PluginRegistry[name], opts]
+      end
+    end
+
+    # Connections required by the enabled plugins and their tools, as
+    # [connection_name, requester_label] pairs, for ConnectionRegistry.validate!.
+    def required_connections
+      requirements = []
+      enabled_plugins.each do |name, plugin_class, _opts|
+        next unless plugin_class
+
+        Array(plugin_class.required_connections).each do |conn_name|
+          requirements << [conn_name, "Plugin #{name.inspect}"]
+        end
+        plugin_class.tools.each do |tool_class|
+          requirements << [tool_class.connection, "Tool #{tool_class.tool_name.inspect}"] if tool_class.connection
+        end
+      end
+      requirements
+    end
+
+    # Requires every .rb under app/talk_to_your_app/<subdir> so the files'
+    # side effects run (CustomTool subclasses register; health checks call
+    # Health.register). require is idempotent, so calling this repeatedly loads
+    # each file once per process (edits need a restart). No-op when the directory
+    # or Rails is absent. Each file is loaded in isolation: one file that fails
+    # to load is logged and skipped so it can't suppress the others. ScriptError
+    # is rescued alongside StandardError so a syntax/load error is reported the
+    # same way as a runtime error rather than escaping uncaught.
+    def require_app_dir(subdir)
+      return unless defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+
+      dir = ::Rails.root.join(APP_DIR, subdir)
+      return unless File.directory?(dir)
+
+      Dir[File.join(dir, "**/*.rb")].sort.each do |file|
+        require file
+      rescue StandardError, ScriptError => e
+        message = "talk_to_your_app: failed to load #{file}: #{e.class}: #{e.message}"
+        logger = configuration.logger
+        logger ? logger.error(message) : $stderr.puts(message)
+      end
+    end
+  end
+end
+
+require_relative "talk_to_your_app/railtie" if defined?(Rails::Railtie)
+
+# Bundled plugins self-register on load (after register_plugin is defined). They
+# are off by default; the operator enables them in the initializer. Soft-dep
+# constants are referenced only inside tool calls, so loading these files never
+# requires the backing gem.
+require_relative "talk_to_your_app/plugins/db/plugin"
+require_relative "talk_to_your_app/plugins/jobs/plugin"
+require_relative "talk_to_your_app/plugins/flipper/plugin"
+require_relative "talk_to_your_app/plugins/health/plugin"
+require_relative "talk_to_your_app/plugins/rake/plugin"
+require_relative "talk_to_your_app/plugins/custom_tools/plugin"

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: talk_to_your_app
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.1
+platform: ruby
+authors:
+- Igor
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: |
+  A thin Rails layer over the official MCP Ruby SDK. Mounts a Streamable HTTP
+  MCP endpoint, gates access behind API-key or HTTP Basic auth, enforces
+  fail-closed per-tool database roles, and ships six bundled plugins
+  (DB, Jobs, Flipper, Health, Rake, Custom Tools) plus a Ruby DSL for
+  writing your own.
+email:
+- igor@everai.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/generators/talk_to_your_app/custom_tool/custom_tool_generator.rb
+- lib/generators/talk_to_your_app/custom_tool/templates/tool.rb.tt
+- lib/generators/talk_to_your_app/health_check/health_check_generator.rb
+- lib/generators/talk_to_your_app/health_check/templates/check.rb.tt
+- lib/generators/talk_to_your_app/install/install_generator.rb
+- lib/generators/talk_to_your_app/install/templates/initializer.rb.tt
+- lib/talk_to_your_app.rb
+- lib/talk_to_your_app/audit_logger.rb
+- lib/talk_to_your_app/auth/api_key.rb
+- lib/talk_to_your_app/auth/basic.rb
+- lib/talk_to_your_app/auth/middleware.rb
+- lib/talk_to_your_app/configuration.rb
+- lib/talk_to_your_app/connection_registry.rb
+- lib/talk_to_your_app/current.rb
+- lib/talk_to_your_app/custom_tool.rb
+- lib/talk_to_your_app/plugin.rb
+- lib/talk_to_your_app/plugin_registry.rb
+- lib/talk_to_your_app/plugins/custom_tools/plugin.rb
+- lib/talk_to_your_app/plugins/db/plugin.rb
+- lib/talk_to_your_app/plugins/db/tools/query.rb
+- lib/talk_to_your_app/plugins/db/tools/schema.rb
+- lib/talk_to_your_app/plugins/db/tools/tables.rb
+- lib/talk_to_your_app/plugins/flipper/plugin.rb
+- lib/talk_to_your_app/plugins/flipper/tools/disable_flag.rb
+- lib/talk_to_your_app/plugins/flipper/tools/enable_flag.rb
+- lib/talk_to_your_app/plugins/flipper/tools/enabled_flags.rb
+- lib/talk_to_your_app/plugins/flipper/tools/list_flags.rb
+- lib/talk_to_your_app/plugins/flipper/tools/read_flag.rb
+- lib/talk_to_your_app/plugins/health/plugin.rb
+- lib/talk_to_your_app/plugins/health/registry.rb
+- lib/talk_to_your_app/plugins/health/tools/list_checks.rb
+- lib/talk_to_your_app/plugins/health/tools/run_check.rb
+- lib/talk_to_your_app/plugins/jobs/adapters/sidekiq.rb
+- lib/talk_to_your_app/plugins/jobs/adapters/solid_queue.rb
+- lib/talk_to_your_app/plugins/jobs/interface.rb
+- lib/talk_to_your_app/plugins/jobs/plugin.rb
+- lib/talk_to_your_app/plugins/jobs/tools/failed_jobs.rb
+- lib/talk_to_your_app/plugins/jobs/tools/health.rb
+- lib/talk_to_your_app/plugins/jobs/tools/queue_sizes.rb
+- lib/talk_to_your_app/plugins/jobs/tools/rate_metrics.rb
+- lib/talk_to_your_app/plugins/jobs/tools/recent_jobs.rb
+- lib/talk_to_your_app/plugins/rake/plugin.rb
+- lib/talk_to_your_app/plugins/rake/tools/run.rb
+- lib/talk_to_your_app/railtie.rb
+- lib/talk_to_your_app/renderers/html_table.rb
+- lib/talk_to_your_app/tool.rb
+- lib/talk_to_your_app/transport/rails_mount.rb
+- lib/talk_to_your_app/version.rb
+homepage: https://github.com/everai/talk_to_your_app
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/everai/talk_to_your_app
+  source_code_uri: https://github.com/everai/talk_to_your_app
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: 'Rails-native MCP server: ask your running app real questions over MCP.'
+test_files: []