codebase_index 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b4a8714907098ba15578b80015b9d20bcf7b3d10da54f211321656c3583bcf9
-  data.tar.gz: 3b9b8b03f66e7126b74199688fd89264c4abc9850ce104c9657faf41d3827db7
+  metadata.gz: 8ba2df9baa16005b8f3981639c0e1bca59bbff3382c1cd483e2a686d399054f4
+  data.tar.gz: '0983e4f7e63febbe63631bff76caab5d11cc88dec9e360eab2a3ea33f6adb025'
 SHA512:
-  metadata.gz: d08c8bf05ba7d74ee664abb13340fedbf50cce318a6a83a0ef9d42dadce8d85600cda3c56b867feafc2f09949c9735786c28edd2647542cec336d4496a476711
-  data.tar.gz: c366e25d8efdde76f11a8b8e4267cbdfe098b567041e28fbc49071ebcf7143e2a7e530a1033888dadf26965888f14f9a1a3a306d668e3e87c28d4cb441f29a36
+  metadata.gz: 25af1daf07cdbdbf810919db95f8dd9535b79c784e6fc74aad5885931221ca9c389507fd67eb1a1e5ec2cb3f5415fc111c4946db27a29df1882975a0741eb2f8
+  data.tar.gz: 5a9e35f69d822a8cc0e12a82a0d33fad0fdc6fac61d65c88e4c00ccfe8fbda5b7f7bcde0a82f7051a3238e43b60f1a8143dc35a28486fbc8e6818770b9d98693

data/README.md

@@ -191,6 +191,55 @@ codebase-console-mcp
 
 See [docs/MCP_SERVERS.md](docs/MCP_SERVERS.md) for the full tool catalog and setup instructions.
 
+### Claude Code Setup
+
+Add the servers to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "codebase-index": {
+      "command": "codebase-index-mcp",
+      "args": ["/path/to/rails-app/tmp/codebase_index"]
+    },
+    "codebase-console": {
+      "command": "bundle",
+      "args": ["exec", "rake", "codebase_index:console"],
+      "cwd": "/path/to/rails-app"
+    }
+  }
+}
+```
+
+The **index server** reads from a pre-extracted directory — run `bundle exec rake codebase_index:extract` in your Rails app first.
+
+The **console server** runs embedded inside your Rails app (no config file needed). For Docker:
+
+```json
+{
+  "mcpServers": {
+    "codebase-console": {
+      "command": "docker",
+      "args": ["exec", "-i", "my_container", "bundle", "exec", "rake", "codebase_index:console"]
+    }
+  }
+}
+```
+
+### Validation
+
+Verify each server starts and lists its tools:
+
+```bash
+# Index server — should list 27 tools
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | \
+  codebase-index-mcp /path/to/rails-app/tmp/codebase_index
+
+# Console server — should list 31 tools (requires Rails app)
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | \
+  bundle exec rake codebase_index:console
+```
+
 ## Subsystems
 
 ```

data/exe/codebase-console

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Embedded console MCP server — runs inside a Rails environment.
+#
+# Usage (via rake, recommended):
+#   bundle exec rake codebase_index:console
+#
+# Usage (via rails runner):
+#   bundle exec rails runner "$(bundle show codebase_index)/exe/codebase-console"
+#
+# The rake task captures stdout before Rails boots and passes the fd via
+# $codebase_index_protocol_out. When run via rails runner, this script
+# captures stdout itself to keep MCP protocol clean.
+
+# Check if the rake task already captured stdout for us.
+protocol_out = $codebase_index_protocol_out # rubocop:disable Style/GlobalVars
+
+unless protocol_out
+  # Running via rails runner — capture stdout ourselves.
+  protocol_out = $stdout.dup
+  $stdout.reopen($stderr)
+end
+
+require 'codebase_index/console/server'
+
+# Ensure all application models are loaded for the registry.
+Rails.application.eager_load!
+
+registry = ActiveRecord::Base.descendants.each_with_object({}) do |model, hash|
+  next if model.abstract_class?
+  next unless model.table_exists?
+
+  hash[model.name] = model.column_names
+rescue StandardError
+  next
+end
+
+validator = CodebaseIndex::Console::ModelValidator.new(registry: registry)
+safe_context = CodebaseIndex::Console::SafeContext.new(connection: ActiveRecord::Base.connection)
+
+redacted_columns = if CodebaseIndex.respond_to?(:configuration) && CodebaseIndex.configuration
+                     Array(CodebaseIndex.configuration.console_redacted_columns)
+                   else
+                     []
+                   end
+
+server = CodebaseIndex::Console::Server.build_embedded(
+  model_validator: validator,
+  safe_context: safe_context,
+  redacted_columns: redacted_columns
+)
+
+# Restore the protocol output for MCP transport.
+$stdout.reopen(protocol_out)
+protocol_out.close unless protocol_out.closed?
+
+transport = MCP::Server::Transports::StdioTransport.new(server)
+transport.open

data/lib/codebase_index/console/embedded_executor.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require_relative 'model_validator'
+require_relative 'safe_context'
+
+module CodebaseIndex
+  module Console
+    # Drop-in replacement for ConnectionManager + Bridge that executes
+    # queries directly via ActiveRecord instead of a separate bridge process.
+    #
+    # Implements the same `send_request(Hash) -> Hash` interface as
+    # ConnectionManager, so all existing tool definitions in Server work
+    # unchanged — just pass this where `conn_mgr` goes.
+    #
+    # @example
+    #   executor = EmbeddedExecutor.new(model_validator: validator, safe_context: ctx)
+    #   response = executor.send_request({ 'tool' => 'count', 'params' => { 'model' => 'User' } })
+    #   # => { 'ok' => true, 'result' => { 'count' => 42 }, 'timing_ms' => 1.2 }
+    #
+    class EmbeddedExecutor # rubocop:disable Metrics/ClassLength
+      AGGREGATE_FUNCTIONS = %w[sum average minimum maximum].freeze
+
+      TIER1_TOOLS = %w[count sample find pluck aggregate association_count schema recent status].freeze
+
+      # @param model_validator [ModelValidator] Validates model/column names
+      # @param safe_context [SafeContext] Wraps execution in rolled-back transaction
+      # @param connection [Object, nil] Database connection for adapter detection
+      def initialize(model_validator:, safe_context:, connection: nil)
+        @model_validator = model_validator
+        @safe_context = safe_context
+        @connection = connection
+      end
+
+      # Execute a tool request and return a response hash.
+      #
+      # Compatible with ConnectionManager#send_request — Server's `send_to_bridge`
+      # calls this method and expects `{ 'ok' => true/false, ... }`.
+      #
+      # @param request [Hash] Request with 'tool' and 'params' keys
+      # @return [Hash] Response with 'ok', 'result'/'error', and 'timing_ms'
+      def send_request(request)
+        # Deep-stringify keys — Tier1 tool builders use symbol keys, but the bridge
+        # path naturally stringifies via JSON round-trip. Replicate that here.
+        request = deep_stringify_keys(request)
+        tool = request['tool']
+        params = request['params'] || {}
+
+        unless TIER1_TOOLS.include?(tool)
+          return { 'ok' => false,
+                   'error' => 'Not yet implemented in embedded mode',
+                   'error_type' => 'unsupported' }
+        end
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = @safe_context.execute { dispatch(tool, params) }
+        elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(1)
+
+        { 'ok' => true, 'result' => result, 'timing_ms' => elapsed }
+      rescue ValidationError => e
+        { 'ok' => false, 'error' => e.message, 'error_type' => 'validation' }
+      rescue StandardError => e
+        { 'ok' => false, 'error' => e.message, 'error_type' => 'execution' }
+      end
+
+      private
+
+      # Route a tool name to its handler.
+      #
+      # @param tool [String] Tool name
+      # @param params [Hash] Tool parameters
+      # @return [Hash] Tool result
+      def dispatch(tool, params)
+        case tool
+        when 'status'  then handle_status
+        when 'schema'  then handle_schema(params)
+        else
+          validate_model!(params)
+          send(:"handle_#{tool}", params)
+        end
+      end
+
+      # @param params [Hash] Must contain 'model' key
+      # @raise [ValidationError]
+      def validate_model!(params)
+        model = params['model']
+        raise ValidationError, 'Missing required parameter: model' unless model
+
+        @model_validator.validate_model!(model)
+      end
+
+      # Resolve a model name string to an ActiveRecord class.
+      #
+      # @param name [String] Model class name (e.g., 'User', 'Admin::Account')
+      # @return [Class] The ActiveRecord model class
+      def resolve_model(name)
+        name.constantize
+      end
+
+      # ── Tier 1 Handlers ──────────────────────────────────────────────────
+
+      def handle_count(params)
+        model = resolve_model(params['model'])
+        scope = apply_scope(model, params['scope'])
+        { 'count' => scope.count }
+      end
+
+      def handle_sample(params)
+        model = resolve_model(params['model'])
+        limit = [params.fetch('limit', 5).to_i, 25].min
+        scope = apply_scope(model, params['scope'])
+        scope = apply_columns(scope, params['columns'])
+        records = scope.order(random_function).limit(limit)
+        { 'records' => serialize_records(records, params['columns']) }
+      end
+
+      def handle_find(params)
+        model = resolve_model(params['model'])
+        record = if params['id']
+                   model.find_by(id: params['id'])
+                 elsif params['by']
+                   model.find_by(params['by'])
+                 end
+        { 'record' => record ? serialize_record(record, params['columns']) : nil }
+      end
+
+      def handle_pluck(params)
+        columns = params['columns']
+        @model_validator.validate_columns!(params['model'], columns) if columns
+        model = resolve_model(params['model'])
+        limit = [params.fetch('limit', 100).to_i, 1000].min
+        scope = apply_scope(model, params['scope'])
+        scope = scope.distinct if params['distinct']
+        values = scope.limit(limit).pluck(*columns.map(&:to_sym))
+        { 'values' => values }
+      end
+
+      def handle_aggregate(params)
+        column = params['column']
+        function = params['function']
+        @model_validator.validate_column!(params['model'], column) if column
+
+        unless AGGREGATE_FUNCTIONS.include?(function)
+          raise ValidationError, "Invalid aggregate function: #{function}. " \
+                                 "Allowed: #{AGGREGATE_FUNCTIONS.join(', ')}"
+        end
+
+        model = resolve_model(params['model'])
+        scope = apply_scope(model, params['scope'])
+        { 'value' => scope.send(function.to_sym, column.to_sym) }
+      end
+
+      def handle_association_count(params)
+        model = resolve_model(params['model'])
+        record = model.find(params['id'])
+        association_name = params['association']
+
+        unless model.reflect_on_association(association_name.to_sym)
+          raise ValidationError, "Unknown association '#{association_name}' on #{params['model']}"
+        end
+
+        scope = record.public_send(association_name)
+        scope = apply_scope(scope, params['scope'])
+        { 'count' => scope.count }
+      end
+
+      def handle_schema(params)
+        model_name = params['model']
+        raise ValidationError, 'Missing required parameter: model' unless model_name
+
+        @model_validator.validate_model!(model_name)
+        model = resolve_model(model_name)
+
+        columns = model.columns_hash.transform_values do |col|
+          { 'type' => col.type.to_s, 'null' => col.null, 'default' => col.default&.to_s }
+        end
+
+        result = { 'columns' => columns }
+
+        if params['include_indexes']
+          indexes = model.connection.indexes(model.table_name).map do |idx|
+            { 'name' => idx.name, 'columns' => idx.columns, 'unique' => idx.unique }
+          end
+          result['indexes'] = indexes
+        end
+
+        result
+      end
+
+      def handle_recent(params)
+        model = resolve_model(params['model'])
+        order_by = params.fetch('order_by', 'created_at')
+        direction = params.fetch('direction', 'desc')
+        limit = [params.fetch('limit', 10).to_i, 50].min
+
+        @model_validator.validate_column!(params['model'], order_by)
+        direction = 'desc' unless %w[asc desc].include?(direction)
+
+        scope = apply_scope(model, params['scope'])
+        scope = apply_columns(scope, params['columns'])
+        records = scope.order(order_by => direction.to_sym).limit(limit)
+        { 'records' => serialize_records(records, params['columns']) }
+      end
+
+      def handle_status
+        adapter = begin
+          active_connection.adapter_name
+        rescue StandardError
+          'unknown'
+        end
+        { 'status' => 'ok', 'models' => @model_validator.model_names, 'adapter' => adapter }
+      end
+
+      # ── Helpers ──────────────────────────────────────────────────────────
+
+      # Apply scope conditions (WHERE clauses) to a relation.
+      #
+      # @param relation [ActiveRecord::Relation, Class] Model or relation
+      # @param scope [Hash, nil] Filter conditions
+      # @return [ActiveRecord::Relation]
+      def apply_scope(relation, scope)
+        return relation unless scope.is_a?(Hash) && scope.any?
+
+        relation.where(scope)
+      end
+
+      # Apply column selection to a relation.
+      #
+      # @param relation [ActiveRecord::Relation] The relation
+      # @param columns [Array<String>, nil] Columns to select
+      # @return [ActiveRecord::Relation]
+      def apply_columns(relation, columns)
+        return relation unless columns.is_a?(Array) && columns.any?
+
+        relation.select(columns)
+      end
+
+      # Serialize a single record to a Hash.
+      #
+      # @param record [ActiveRecord::Base] The record
+      # @param columns [Array<String>, nil] Columns to include
+      # @return [Hash]
+      def serialize_record(record, columns = nil)
+        if columns.is_a?(Array) && columns.any?
+          record.attributes.slice(*columns)
+        else
+          record.attributes
+        end
+      end
+
+      # Serialize multiple records.
+      #
+      # @param records [ActiveRecord::Relation] The records
+      # @param columns [Array<String>, nil] Columns to include
+      # @return [Array<Hash>]
+      def serialize_records(records, columns = nil)
+        records.map { |r| serialize_record(r, columns) }
+      end
+
+      # DB-dialect-aware random ordering function.
+      #
+      # @return [Arel::Nodes::SqlLiteral]
+      def random_function
+        adapter = active_connection.adapter_name.downcase
+        func = adapter.include?('mysql') ? 'RAND' : 'RANDOM'
+        Arel.sql("#{func}()")
+      end
+
+      # Return the database connection (injected or from ActiveRecord).
+      #
+      # @return [Object] Database connection
+      def active_connection
+        @connection || ActiveRecord::Base.connection
+      end
+
+      # Recursively convert all Hash keys to strings.
+      #
+      # @param obj [Object] The object to stringify
+      # @return [Object] Object with string keys
+      def deep_stringify_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify_keys(v) }
+        when Array
+          obj.map { |item| deep_stringify_keys(item) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/codebase_index/console/rack_middleware.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CodebaseIndex
+  module Console
+    # Rack middleware that serves the embedded console MCP server over HTTP.
+    #
+    # Lazy-builds the MCP server on first request so Rails has fully booted
+    # and all models are loaded. Uses ActiveRecord connection pool for thread
+    # safety under Puma.
+    #
+    # @example In config/application.rb or an initializer:
+    #   config.middleware.use CodebaseIndex::Console::RackMiddleware, path: '/mcp/console'
+    #
+    class RackMiddleware
+      # @param app [#call] The next Rack app in the middleware stack
+      # @param path [String] URL path to mount the MCP endpoint (default: '/mcp/console')
+      def initialize(app, path: '/mcp/console')
+        @app = app
+        @path = path
+        @mutex = Mutex.new
+        @transport = nil
+      end
+
+      # Rack interface — intercepts requests at the configured path.
+      #
+      # @param env [Hash] Rack environment
+      # @return [Array] Rack response triple
+      def call(env)
+        return @app.call(env) unless env['PATH_INFO'].start_with?(@path)
+
+        transport = ensure_transport
+        request = Rack::Request.new(env)
+        transport.handle_request(request)
+      end
+
+      private
+
+      # Thread-safe lazy initialization of the MCP server and transport.
+      #
+      # @return [MCP::Server::Transports::StreamableHTTPTransport]
+      def ensure_transport # rubocop:disable Metrics/MethodLength
+        return @transport if @transport
+
+        @mutex.synchronize do
+          return @transport if @transport
+
+          require 'codebase_index/console/server'
+
+          Rails.application.eager_load!
+
+          registry = ActiveRecord::Base.descendants.each_with_object({}) do |model, hash|
+            next if model.abstract_class?
+            next unless model.table_exists?
+
+            hash[model.name] = model.column_names
+          rescue StandardError
+            next
+          end
+
+          validator = ModelValidator.new(registry: registry)
+
+          config = CodebaseIndex.configuration
+          redacted = Array(config.console_redacted_columns)
+
+          # Each HTTP request gets its own connection from the pool.
+          # SafeContext wraps that connection in a rolled-back transaction.
+          safe_context = SafeContext.new(connection: ActiveRecord::Base.connection)
+
+          server = Server.build_embedded(
+            model_validator: validator,
+            safe_context: safe_context,
+            redacted_columns: redacted
+          )
+
+          @transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
+          server.transport = @transport
+          @transport
+        end
+      end
+    end
+  end
+end

data/lib/codebase_index/console/server.rb

@@ -34,7 +34,7 @@ module CodebaseIndex
       TIER4_TOOLS = %w[eval sql query].freeze
 
       class << self # rubocop:disable Metrics/ClassLength
-        # Build a configured MCP::Server with console tools.
+        # Build a configured MCP::Server with console tools using the bridge protocol.
         #
         # @param config [Hash] Configuration hash (from YAML or env)
         # @return [MCP::Server] Configured server ready for transport
@@ -44,24 +44,37 @@ module CodebaseIndex
           redacted_columns = Array(config['redacted_columns'] || connection_config['redacted_columns'])
           safe_ctx = redacted_columns.any? ? SafeContext.new(connection: nil, redacted_columns: redacted_columns) : nil
 
-          server = ::MCP::Server.new(
-            name: 'codebase-console',
-            version: defined?(CodebaseIndex::VERSION) ? CodebaseIndex::VERSION : '0.1.0'
-          )
+          build_server(conn_mgr, safe_ctx)
+        end
 
-          renderer = build_console_renderer
+        # Build a configured MCP::Server using embedded ActiveRecord execution.
+        #
+        # No bridge process needed — queries run directly via ActiveRecord.
+        # Pass the returned server to StdioTransport or StreamableHTTPTransport.
+        #
+        # @param model_validator [ModelValidator] Validates model/column names
+        # @param safe_context [SafeContext] Wraps queries in rolled-back transactions
+        # @param redacted_columns [Array<String>] Column names to redact from output
+        # @param connection [Object, nil] Database connection for adapter detection
+        # @return [MCP::Server] Configured server ready for transport
+        def build_embedded(model_validator:, safe_context:, redacted_columns: [], connection: nil)
+          require_relative 'embedded_executor'
 
-          register_tier1_tools(server, conn_mgr, safe_ctx, renderer: renderer)
-          register_tier2_tools(server, conn_mgr, safe_ctx, renderer: renderer)
-          register_tier3_tools(server, conn_mgr, safe_ctx, renderer: renderer)
-          register_tier4_tools(server, conn_mgr, safe_ctx, renderer: renderer)
-          server
+          executor = EmbeddedExecutor.new(
+            model_validator: model_validator, safe_context: safe_context, connection: connection
+          )
+          redact_ctx = if redacted_columns.any?
+                         SafeContext.new(connection: nil,
+                                         redacted_columns: redacted_columns)
+                       end
+
+          build_server(executor, redact_ctx)
         end
 
         # Register Tier 1 read-only tools on the server.
         #
         # @param server [MCP::Server] The MCP server instance
-        # @param conn_mgr [ConnectionManager] Bridge connection
+        # @param conn_mgr [ConnectionManager, EmbeddedExecutor] Request executor
         # @param safe_ctx [SafeContext, nil] Optional context for column redaction
         # @return [void]
         def register_tier1_tools(server, conn_mgr, safe_ctx = nil, renderer: nil)
@@ -71,7 +84,7 @@ module CodebaseIndex
         # Register Tier 2 domain-aware tools on the server.
         #
         # @param server [MCP::Server] The MCP server instance
-        # @param conn_mgr [ConnectionManager] Bridge connection
+        # @param conn_mgr [ConnectionManager, EmbeddedExecutor] Request executor
         # @param safe_ctx [SafeContext, nil] Optional context for column redaction
         # @return [void]
         def register_tier2_tools(server, conn_mgr, safe_ctx = nil, renderer: nil)
@@ -81,7 +94,7 @@ module CodebaseIndex
         # Register Tier 3 analytics tools on the server.
         #
         # @param server [MCP::Server] The MCP server instance
-        # @param conn_mgr [ConnectionManager] Bridge connection
+        # @param conn_mgr [ConnectionManager, EmbeddedExecutor] Request executor
         # @param safe_ctx [SafeContext, nil] Optional context for column redaction
         # @return [void]
         def register_tier3_tools(server, conn_mgr, safe_ctx = nil, renderer: nil)
@@ -91,7 +104,7 @@ module CodebaseIndex
         # Register Tier 4 guarded tools on the server.
         #
         # @param server [MCP::Server] The MCP server instance
-        # @param conn_mgr [ConnectionManager] Bridge connection
+        # @param conn_mgr [ConnectionManager, EmbeddedExecutor] Request executor
         # @param safe_ctx [SafeContext, nil] Optional context for column redaction
         # @return [void]
         def register_tier4_tools(server, conn_mgr, safe_ctx = nil, renderer: nil)
@@ -100,6 +113,26 @@ module CodebaseIndex
 
         private
 
+        # Shared server construction used by both build() and build_embedded().
+        #
+        # @param conn_mgr [ConnectionManager, EmbeddedExecutor] Any object with send_request(Hash) -> Hash
+        # @param safe_ctx [SafeContext, nil] Optional context for column redaction
+        # @return [MCP::Server]
+        def build_server(conn_mgr, safe_ctx)
+          server = ::MCP::Server.new(
+            name: 'codebase-console',
+            version: defined?(CodebaseIndex::VERSION) ? CodebaseIndex::VERSION : '0.1.0'
+          )
+
+          renderer = build_console_renderer
+
+          register_tier1_tools(server, conn_mgr, safe_ctx, renderer: renderer)
+          register_tier2_tools(server, conn_mgr, safe_ctx, renderer: renderer)
+          register_tier3_tools(server, conn_mgr, safe_ctx, renderer: renderer)
+          register_tier4_tools(server, conn_mgr, safe_ctx, renderer: renderer)
+          server
+        end
+
         def respond(text)
           ::MCP::Tool::Response.new([{ type: 'text', text: text }])
         end
@@ -112,13 +145,14 @@ module CodebaseIndex
             text = renderer ? renderer.render_default(result) : JSON.pretty_generate(result)
             respond(text)
           else
+            error_text = "#{response['error_type']}: #{response['error']}"
             ::MCP::Tool::Response.new(
-              [{ type: 'text', text: "#{response['error_type']}: #{response['error']}" }],
-              is_error: true
+              [{ type: 'text', text: error_text }],
+              error: error_text
             )
           end
         rescue ConnectionError => e
-          ::MCP::Tool::Response.new([{ type: 'text', text: "Connection error: #{e.message}" }], is_error: true)
+          ::MCP::Tool::Response.new([{ type: 'text', text: "Connection error: #{e.message}" }], error: e.message)
         end
 
         # Apply SafeContext column redaction to a result value.
@@ -536,11 +570,12 @@ module CodebaseIndex
           mgr = conn_mgr
           ctx = safe_ctx
           rdr = renderer
+          bridge_method = method(:send_to_bridge)
           schema = { properties: properties }
           schema[:required] = required if required&.any?
           server.define_tool(name: name, description: description, input_schema: schema) do |server_context:, **args|
             request = tool_block.call(args)
-            send_to_bridge(mgr, request.transform_keys(&:to_s), ctx, renderer: rdr)
+            bridge_method.call(mgr, request.transform_keys(&:to_s), ctx, renderer: rdr)
           end
         end
         # rubocop:enable Metrics/ParameterLists

data/lib/codebase_index/railtie.rb

@@ -22,5 +22,17 @@ module CodebaseIndex
         )
       end
     end
+
+    initializer 'codebase_index.console_mcp' do |app|
+      config = CodebaseIndex.configuration
+      if config.console_mcp_enabled
+        require 'codebase_index/console/rack_middleware'
+
+        app.middleware.use(
+          CodebaseIndex::Console::RackMiddleware,
+          path: config.console_mcp_path
+        )
+      end
+    end
   end
 end

data/lib/codebase_index/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodebaseIndex
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

data/lib/codebase_index.rb

@@ -41,10 +41,11 @@ module CodebaseIndex
                   :vector_store_options, :metadata_store_options, :embedding_options,
                   :concurrent_extraction, :precompute_flows, :enable_snapshots,
                   :session_tracer_enabled, :session_store, :session_id_proc, :session_exclude_paths,
+                  :console_mcp_enabled, :console_mcp_path, :console_redacted_columns,
                   :notion_api_token, :notion_database_ids
     attr_reader :max_context_tokens, :similarity_threshold, :extractors, :pretty_json, :context_format
 
-    def initialize
+    def initialize # rubocop:disable Metrics/MethodLength
       @output_dir = nil # Resolved lazily; Rails.root is nil at require time
       @embedding_model = 'text-embedding-3-small'
       @max_context_tokens = 8000
@@ -62,6 +63,9 @@ module CodebaseIndex
       @session_store = nil
       @session_id_proc = nil
       @session_exclude_paths = []
+      @console_mcp_enabled = false
+      @console_mcp_path = '/mcp/console'
+      @console_redacted_columns = []
       @notion_api_token = nil
       @notion_database_ids = {}
     end

data/lib/tasks/codebase_index.rake

@@ -538,6 +538,20 @@ namespace :codebase_index do
     end
   end
 
+  desc 'Start the embedded console MCP server (stdio transport)'
+  task :console do
+    # Capture stdout before Rails boot to keep MCP protocol clean.
+    # Rails boot emits OpenTelemetry, gem warnings, etc. to stdout —
+    # MCP client cannot parse these as JSON-RPC.
+    # Global variable passes the fd to exe/codebase-console via load.
+    $codebase_index_protocol_out = $stdout.dup # rubocop:disable Style/GlobalVars
+    $stdout.reopen($stderr)
+
+    Rake::Task[:environment].invoke
+
+    load File.expand_path('../../exe/codebase-console', __dir__)
+  end
+
   desc 'Sync extraction data to Notion databases (Data Models + Columns)'
   task notion_sync: :environment do
     require 'codebase_index/notion/exporter'

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: codebase_index
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Leah Armstrong
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mcp
@@ -46,10 +47,11 @@ description: |
 email:
 - info@leah.wtf
 executables:
-- codebase-console-mcp
 - codebase-index-mcp
-- codebase-index-mcp-http
 - codebase-index-mcp-start
+- codebase-console-mcp
+- codebase-console
+- codebase-index-mcp-http
 extensions: []
 extra_rdoc_files: []
 files:
@@ -58,6 +60,7 @@ files:
 - CONTRIBUTING.md
 - LICENSE.txt
 - README.md
+- exe/codebase-console
 - exe/codebase-console-mcp
 - exe/codebase-index-mcp
 - exe/codebase-index-mcp-http
@@ -80,7 +83,9 @@ files:
 - lib/codebase_index/console/confirmation.rb
 - lib/codebase_index/console/connection_manager.rb
 - lib/codebase_index/console/console_response_renderer.rb
+- lib/codebase_index/console/embedded_executor.rb
 - lib/codebase_index/console/model_validator.rb
+- lib/codebase_index/console/rack_middleware.rb
 - lib/codebase_index/console/safe_context.rb
 - lib/codebase_index/console/server.rb
 - lib/codebase_index/console/sql_validator.rb
@@ -227,11 +232,12 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/LeahArmstrong/codebase_index
-  source_code_uri: https://github.com/LeahArmstrong/codebase_index
+  source_code_uri: https://github.com/LeahArmstrong/codebase_index/tree/main
   changelog_uri: https://github.com/LeahArmstrong/codebase_index/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/LeahArmstrong/codebase_index/issues
   documentation_uri: https://github.com/LeahArmstrong/codebase_index/tree/main/docs
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -246,7 +252,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Rails codebase extraction and indexing for AI-assisted development
 test_files: []