rails_console_ai 0.13.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98ae3edf9aa6ff90817a965a826abaac229c14cba7a76f5eb27f3fea0e1defc4
+  data.tar.gz: 410831834a4a68bcd23693ee185d437c76b648c533b9c2f9d89c83c2ce376d39
+SHA512:
+  metadata.gz: ecec76ab83d0bc42a7216e1180d447bddf092556a5e600dad784da6826f613d7145e81e65bd768aafab1858a434a2193e6370315d5601cf668e23da0bcad40d9
+  data.tar.gz: eef36ae45dfda23ca47a95524afc7ebb76083a927162c79263c5d3c98a0726ec1bb20b5fcf2e29b03b2c480044484c6bec36dbac466035092e969a6d7d2e5747

data/CHANGELOG.md

@@ -0,0 +1,95 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.13.0]
+
+- Rename gem from `console_agent` to `rails_console_ai`
+- Add AWS Bedrock provider
+- Add prompt caching and cache-aware cost tracking for Anthropic
+- Enable prompt caching for Bedrock
+
+## [0.12.0]
+
+- Add `slack_allowed_usernames` to restrict Slack channel access
+
+## [0.11.0]
+
+- Add Slack channel integration with system instructions and connection pooling
+- Extract channels abstraction and ConversationEngine from Repl
+- Add built-in safety guards with `/danger` bypass and progressive safety allowlists
+- Add local model support with prompt truncation warnings
+- Add `clear!` command to clear bot messages in thread
+- Match code blocks in LLM results
+- Fix long query display and add cost tracking to session viewer
+- Strip quotes from session names when saving
+
+## [0.10.0]
+
+- Add `/expand` command to view previous results
+- Exclude previous output from context; add tool for LLM to retrieve it on demand
+- Show summarized info per LLM call in `/debug`
+
+## [0.9.0]
+
+- Add `/system` and `/context` commands to inspect what is being sent
+- Omit huge output from tool results
+- Don't cancel code execution on incorrect prompt answers
+- Preserve code blocks when compacting; require manual `/compact`
+- Fix authentication when neither method was applied
+- Remove prompt to upgrade model on excessive tool calls
+
+## [0.8.0]
+
+- Add authentication function support so host apps can avoid using basic auth
+- Add `/think` and `/cost` commands with Sonnet vs Opus support
+- Gracefully handle token limit exceeded errors
+
+## [0.7.0]
+
+- Include binding variables and their classes in the Rails console context
+- Add `ai_setup` command
+- Add `/compact` mechanism for conversation management
+- Catch errors and attempt to auto-fix them
+
+## [0.6.0]
+
+- Add core memory (`rails_console_ai.md`) that persists across sessions in the system prompt
+- Add `ai_init` command to seed core memory
+- Allow reading partial files
+- Fix rspec hanging issues
+
+## [0.5.0]
+
+- Auto-accept single-step plans
+- Support `>` shorthand to run code directly
+- Add `script/release` for releases
+
+## [0.4.0]
+
+- Fix resuming sessions repeatedly
+- Fix terminal flashing/loading in production (kubectl)
+- Better escaping during thinking output
+
+## [0.3.0]
+
+- Add plan mechanism with "auto" execution mode
+- Add session logging to DB with `/rails_console_ai` admin UI
+- List and resume past sessions with pagination
+- Add shift-tab for auto-execute mode
+- Add usage display and debug toggle
+- Store sessions incrementally; improved code segment display
+
+## [0.2.0]
+
+- Add memory system with individual file storage
+- Add `ask_user` tool
+- Add registry cache
+- Fix REPL up-key and ctrl-a navigation
+- Show tool usage and model processing info
+- Add token count information and debug ability
+- Use tools-based approach instead of sending everything at once
+
+## [0.1.0]
+
+- Initial implementation

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Frank Cort
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,328 @@
+# RailsConsoleAI
+
+Claude Code for your Rails Console.
+
+```
+irb> ai "find the 5 most recent orders over $100"
+  Thinking...
+  -> list_tables
+     12 tables: users, orders, line_items, products...
+  -> describe_table("orders")
+     8 columns
+
+  Order.where("total > ?", 100).order(created_at: :desc).limit(5)
+
+Execute? [y/N/edit/danger] y
+=> [#<Order id: 4821, ...>, ...]
+```
+
+For complex tasks it builds multi-step plans, executing each step sequentially:
+
+```
+ai> get the most recent salesforce token and count events via the API
+  Plan (2 steps):
+  1. Find the most recent active Salesforce OAuth2 token
+     token = Oauth2Token.where(provider: "salesforce", active: true)
+                        .order(updated_at: :desc).first
+  2. Query event count via SOQL
+     api = SalesforceApi.new(step1)
+     api.query("SELECT COUNT(Id) FROM Event")
+
+  Accept plan? [y/N/a(uto)] a
+```
+
+No context needed from you — it figures out your app on its own.
+
+## Install
+
+```ruby
+# Gemfile
+gem 'rails_console_ai', group: :development
+```
+
+```bash
+bundle install
+rails generate rails_console_ai:install
+```
+
+Set your API key in the generated initializer or via env var (`ANTHROPIC_API_KEY`):
+
+```ruby
+# config/initializers/rails_console_ai.rb
+RailsConsoleAI.configure do |config|
+  config.api_key = 'sk-ant-...'
+end
+```
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `ai "query"` | Ask, review generated code, confirm execution |
+| `ai!` | Enter interactive mode (multi-turn conversation) |
+| `ai? "query"` | Explain only, no execution |
+| `ai_init` | Generate app guide for better AI context |
+| `ai_setup` | Install session logging table |
+| `ai_sessions` | List recent sessions |
+| `ai_resume` | Resume a session by name or ID |
+| `ai_memories` | Show stored memories |
+| `ai_status` | Show current configuration |
+
+### Interactive Mode
+
+`ai!` starts a conversation. Slash commands available inside:
+
+| Command | What it does |
+|---------|-------------|
+| `/auto` | Toggle auto-execute (skip confirmations) |
+| `/danger` | Toggle safe mode off/on (allow side effects) |
+| `/safe` | Show safety guard status |
+| `/compact` | Compress history into a summary (saves tokens) |
+| `/usage` | Show token stats |
+| `/cost` | Show per-model cost breakdown |
+| `/think` | Upgrade to thinking model (Opus) for the rest of the session |
+| `/debug` | Toggle debug summaries (context stats, cost per call) |
+| `/expand <id>` | Show full omitted output |
+| `/context` | Show conversation history as sent to the LLM |
+| `/system` | Show the system prompt |
+| `/name <label>` | Name the session for easy resume |
+
+Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
+
+Say "think harder" in any query to auto-upgrade to the thinking model for that session. After 5+ tool rounds, you'll also be prompted to switch.
+
+## Features
+
+- **Tool use** — AI introspects your schema, models, files, and code to write accurate queries
+- **Multi-step plans** — complex tasks are broken into steps, executed sequentially with `step1`/`step2` references
+- **Two-tier models** — defaults to Sonnet for speed/cost; `/think` upgrades to Opus when you need it
+- **Cost tracking** — `/cost` shows per-model token usage and estimated spend
+- **Memories** — AI saves what it learns about your app across sessions
+- **App guide** — `ai_init` generates a guide injected into every system prompt
+- **Sessions** — name, list, and resume interactive conversations (`ai_setup` to enable)
+- **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
+- **Output trimming** — older execution outputs are automatically replaced with references; the LLM can recall them on demand via `recall_output`, and you can `/expand <id>` to see them
+- **Debug mode** — `/debug` shows context breakdown, token counts, and per-call cost estimates before and after each LLM call
+- **Safe mode** — configurable guards that block side effects (DB writes, HTTP mutations, email delivery) during AI code execution
+
+## Safety Guards
+
+Safety guards prevent AI-generated code from causing side effects. When a guard blocks an operation, the user is prompted to re-run with safe mode disabled.
+
+### Built-in Guards
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.use_builtin_safety_guard :database_writes  # blocks INSERT/UPDATE/DELETE/DROP/etc.
+  config.use_builtin_safety_guard :http_mutations    # blocks POST/PUT/PATCH/DELETE via Net::HTTP
+  config.use_builtin_safety_guard :mailers           # disables ActionMailer delivery
+end
+```
+
+- **`:database_writes`** — intercepts the ActiveRecord connection adapter to block write SQL. Works on Rails 5+ with any database adapter.
+- **`:http_mutations`** — intercepts `Net::HTTP#request` to block non-GET/HEAD/OPTIONS requests. Covers libraries built on Net::HTTP (HTTParty, RestClient, Faraday).
+- **`:mailers`** — sets `ActionMailer::Base.perform_deliveries = false` during execution.
+
+### Custom Guards
+
+Write your own guards using the around-block pattern:
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.safety_guard :jobs do |&execute|
+    Sidekiq::Testing.fake! { execute.call }
+  end
+end
+```
+
+Raise `RailsConsoleAI::SafetyError` in your app code to trigger the safe mode prompt:
+
+```ruby
+raise RailsConsoleAI::SafetyError, "Stripe charge blocked"
+```
+
+### Toggling Safe Mode
+
+- **`/danger`** in interactive mode toggles all guards off/on for the session
+- **`d`** at the `Execute? [y/N/edit/danger]` prompt disables guards for that single execution
+- When a guard blocks an operation, the user is prompted: `Re-run with safe mode disabled? [y/N]`
+
+## LLM Providers
+
+RailsConsoleAI supports four LLM providers. Each uses a two-tier model system: a default model for speed/cost, and a thinking model activated via `/think` or by saying "think harder".
+
+### Anthropic (default)
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.provider = :anthropic
+  config.api_key = 'sk-ant-...'  # or set ANTHROPIC_API_KEY env var
+end
+```
+
+Default model: `claude-sonnet-4-6`. Thinking model: `claude-opus-4-6`. Prompt caching is enabled automatically.
+
+### OpenAI
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.provider = :openai
+  config.api_key = 'sk-...'  # or set OPENAI_API_KEY env var
+end
+```
+
+Default model: `gpt-5.3-codex`. OpenAI applies prompt caching automatically on their end for prompts over 1024 tokens.
+
+### AWS Bedrock
+
+Access frontier models (Claude, Mistral, DeepSeek, Llama) via your AWS account with pay-per-token pricing. No API key needed — authentication uses the AWS SDK credential chain (IAM roles, env vars, `~/.aws/credentials`).
+
+```ruby
+# Gemfile
+gem 'aws-sdk-bedrockruntime'
+```
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.provider = :bedrock
+  config.bedrock_region = 'us-east-1'
+  # config.model = 'us.anthropic.claude-sonnet-4-6'           # default
+  # config.thinking_model = 'us.anthropic.claude-opus-4-6-v1' # default
+end
+```
+
+Bedrock model IDs use the `us.` prefix for cross-region inference profiles (required for on-demand Anthropic models). Non-Anthropic models use their bare ID:
+
+```ruby
+config.model = 'mistral.devstral-2-123b'
+config.model = 'deepseek.v3.2'
+```
+
+**Setup checklist:**
+1. Add `aws-sdk-bedrockruntime` to your Gemfile (it is not a hard dependency of the gem)
+2. Ensure AWS credentials are available to the SDK (env vars, IAM role, or `~/.aws/credentials`)
+3. For Anthropic models, submit the use case form in the Bedrock console (one-time, per account)
+4. The IAM role/user needs `bedrock:InvokeModel` permission
+
+Prompt caching is automatically enabled for Anthropic models on Bedrock, reducing cost on multi-turn tool use conversations.
+
+### Local (Ollama / vLLM / OpenAI-compatible)
+
+Run against a local model server. No API key required.
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.provider = :local
+  config.local_url = 'http://localhost:11434'
+  config.local_model = 'qwen2.5:7b'
+  # config.local_api_key = nil  # if your server requires auth
+end
+```
+
+Timeout is automatically raised to 300s minimum for local models to account for slower inference.
+
+## Configuration
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.provider = :anthropic       # :anthropic, :openai, :bedrock, :local
+  config.auto_execute = false         # true to skip confirmations
+  config.session_logging = true       # requires ai_setup
+  config.temperature = 0.2
+  config.timeout = 30                 # HTTP timeout in seconds
+  config.max_tool_rounds = 200        # safety cap on tool-use loops
+end
+```
+
+## Web UI Authentication
+
+The engine mounts a session viewer at `/rails_console_ai`. By default it's open — you can protect it with basic auth or a custom authentication function.
+
+### Basic Auth
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.admin_username = 'admin'
+  config.admin_password = ENV['CONSOLE_AGENT_PASSWORD']
+end
+```
+
+### Custom Authentication
+
+For apps with their own auth system, pass a proc to `authenticate`. It runs in the controller context, so you have access to `session`, `request`, `redirect_to`, etc.
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.authenticate = proc {
+    user = User.find_by(id: session[:user_id])
+    unless user&.admin?
+      redirect_to '/login'
+    end
+  }
+end
+```
+
+When `authenticate` is set, `admin_username` / `admin_password` are ignored.
+
+## Additional Channels
+
+RailsConsoleAI can run through different channels beyond the Rails console. Each channel is a separate process that connects the same AI engine to a different interface.
+
+### Slack
+
+Run RailsConsoleAI as a Slack bot. Each Slack thread becomes an independent AI session with full tool use, multi-step plans, and safety guards always on.
+
+#### Slack App Setup
+
+1. Create a new app at https://api.slack.com/apps → **Create New App** → **From scratch**
+
+2. **Enable Socket Mode** — Settings → Socket Mode → toggle ON. Generate an App-Level Token with the `connections:write` scope. Copy the `xapp-...` token.
+
+3. **Bot Token Scopes** — OAuth & Permissions → Bot Token Scopes, add:
+   - `chat:write`
+   - `channels:history` (public channels)
+   - `groups:history` (private channels, optional)
+   - `im:history` (direct messages)
+   - `users:read`
+
+4. **Event Subscriptions** — Event Subscriptions → toggle ON, then under "Subscribe to bot events" add:
+   - `message.channels` (public channels)
+   - `message.groups` (private channels, optional)
+   - `message.im` (direct messages)
+
+5. **App Home** — Show Tabs → toggle **Messages Tab** ON and check **"Allow users to send Slash commands and messages from the messages tab"**
+
+6. **Install to workspace** — Install App → Install to Workspace. Copy the `xoxb-...` Bot User OAuth Token.
+
+7. **Invite the bot** to a channel with `/invite @YourBotName`, or DM it directly.
+
+#### Configuration
+
+```ruby
+RailsConsoleAI.configure do |config|
+  config.slack_bot_token = ENV['SLACK_BOT_TOKEN']   # xoxb-...
+  config.slack_app_token = ENV['SLACK_APP_TOKEN']    # xapp-...
+
+  # Optional: restrict to specific Slack channel IDs
+  # config.slack_channel_ids = 'C1234567890,C0987654321'
+
+  # Required: which users the bot responds to (by display name)
+  config.slack_allowed_usernames = ['alice', 'bob']  # or 'ALL' for everyone
+end
+```
+
+#### Running
+
+```bash
+bundle exec rake rails_console_ai:slack
+```
+
+This starts a long-running process (run it separately from your web server). Each new message creates a session; threaded replies continue the conversation. The bot auto-executes code with safety guards always enabled — there is no `/danger` equivalent in Slack.
+
+## Requirements
+
+Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0. For Bedrock: `aws-sdk-bedrockruntime` (loaded lazily, not a hard dependency).
+
+## License
+
+MIT

data/app/controllers/rails_console_ai/application_controller.rb

@@ -0,0 +1,28 @@
+module RailsConsoleAI
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    before_action :rails_console_ai_authenticate!
+
+    private
+
+    def rails_console_ai_authenticate!
+      if (auth = RailsConsoleAI.configuration.authenticate)
+        instance_exec(&auth)
+      else
+        username = RailsConsoleAI.configuration.admin_username
+        password = RailsConsoleAI.configuration.admin_password
+
+        unless username && password
+          head :unauthorized
+          return
+        end
+
+        authenticate_or_request_with_http_basic('RailsConsoleAI Admin') do |u, p|
+          ActiveSupport::SecurityUtils.secure_compare(u, username) &
+            ActiveSupport::SecurityUtils.secure_compare(p, password)
+        end
+      end
+    end
+  end
+end

data/app/controllers/rails_console_ai/sessions_controller.rb

@@ -0,0 +1,16 @@
+module RailsConsoleAI
+  class SessionsController < ApplicationController
+    PER_PAGE = 50
+
+    def index
+      @page = [params[:page].to_i, 1].max
+      @total = Session.count
+      @total_pages = (@total / PER_PAGE.to_f).ceil
+      @sessions = Session.recent.offset((@page - 1) * PER_PAGE).limit(PER_PAGE)
+    end
+
+    def show
+      @session = Session.find(params[:id])
+    end
+  end
+end

data/app/helpers/rails_console_ai/sessions_helper.rb

@@ -0,0 +1,56 @@
+module RailsConsoleAI
+  module SessionsHelper
+    def estimated_cost(session)
+      pricing = Configuration::PRICING[session.model]
+      return nil unless pricing
+
+      (session.input_tokens * pricing[:input]) + (session.output_tokens * pricing[:output])
+    end
+
+    def format_cost(session)
+      cost = estimated_cost(session)
+      return '-' unless cost
+
+      cost < 0.01 ? "<$0.01" : "$#{'%.2f' % cost}"
+    end
+
+    # Convert ANSI escape codes to HTML spans for terminal-style rendering
+    def ansi_to_html(text)
+      return '' if text.nil? || text.empty?
+
+      color_map = {
+        '30' => '#000', '31' => '#e74c3c', '32' => '#2ecc71', '33' => '#f39c12',
+        '34' => '#3498db', '35' => '#9b59b6', '36' => '#1abc9c', '37' => '#ecf0f1',
+        '90' => '#888', '91' => '#ff6b6b', '92' => '#69db7c', '93' => '#ffd43b',
+        '94' => '#74c0fc', '95' => '#da77f2', '96' => '#63e6be', '97' => '#fff'
+      }
+
+      escaped = h(text).to_str
+
+      # Process ANSI codes: colors, bold, dim, reset
+      escaped.gsub!(/\e\[([0-9;]+)m/) do
+        codes = $1.split(';')
+        if codes.include?('0') || $1 == '0'
+          '</span>'
+        else
+          styles = []
+          codes.each do |code|
+            case code
+            when '1' then styles << 'font-weight:bold'
+            when '2' then styles << 'opacity:0.6'
+            when '4' then styles << 'text-decoration:underline'
+            else
+              styles << "color:#{color_map[code]}" if color_map[code]
+            end
+          end
+          styles.empty? ? '' : "<span style=\"#{styles.join(';')}\">"
+        end
+      end
+
+      # Clean up any remaining escape sequences
+      escaped.gsub!(/\e\[[0-9;]*[A-Za-z]/, '')
+
+      escaped.html_safe
+    end
+  end
+end

data/app/models/rails_console_ai/session.rb

@@ -0,0 +1,23 @@
+module RailsConsoleAI
+  class Session < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_sessions'
+
+    validates :query, presence: true
+    validates :conversation, presence: true
+    validates :mode, presence: true, inclusion: { in: %w[one_shot interactive explain slack] }
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :named, ->(name) { where(name: name) }
+    scope :search, ->(q) { where("name LIKE ? OR query LIKE ?", "%#{q}%", "%#{q}%") }
+
+    def self.connection
+      klass = RailsConsoleAI.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+  end
+end

data/app/views/layouts/rails_console_ai/application.html.erb

@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>RailsConsoleAI Admin</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background: #f5f5f5;
+      color: #333;
+      line-height: 1.6;
+    }
+    .header {
+      background: #1a1a2e;
+      color: #fff;
+      padding: 16px 24px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+    .header h1 { font-size: 18px; font-weight: 600; }
+    .header a { color: #8be9fd; text-decoration: none; font-size: 14px; }
+    .container { max-width: 1200px; margin: 24px auto; padding: 0 24px; }
+    table { width: 100%; border-collapse: collapse; background: #fff; border-radius: 8px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
+    th { background: #f8f9fa; text-align: left; padding: 12px 16px; font-size: 13px; font-weight: 600; color: #555; border-bottom: 2px solid #e9ecef; }
+    td { padding: 10px 16px; border-bottom: 1px solid #f0f0f0; font-size: 14px; }
+    tr:hover td { background: #f8f9fa; }
+    a { color: #4a6fa5; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    .badge {
+      display: inline-block; padding: 2px 8px; border-radius: 12px;
+      font-size: 11px; font-weight: 600; text-transform: uppercase;
+    }
+    .badge-one_shot { background: #d4edda; color: #155724; }
+    .badge-interactive { background: #cce5ff; color: #004085; }
+    .badge-explain { background: #fff3cd; color: #856404; }
+    .meta-card {
+      background: #fff; border-radius: 8px; padding: 20px;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 24px;
+    }
+    .meta-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); gap: 12px; }
+    .meta-item label { font-size: 11px; font-weight: 600; color: #888; text-transform: uppercase; display: block; }
+    .meta-item span { font-size: 14px; color: #333; }
+    .terminal {
+      background: #1e1e1e; border-radius: 8px; overflow: hidden;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+    }
+    .terminal pre {
+      background: transparent; color: #d4d4d4;
+      padding: 16px 20px; margin: 0;
+      font-family: "SF Mono", "Monaco", "Menlo", "Consolas", monospace;
+      font-size: 13px; line-height: 1.5;
+      overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;
+    }
+    .mono { font-family: "SF Mono", "Monaco", "Menlo", "Consolas", monospace; font-size: 13px; }
+    .query-cell { max-width: 400px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .text-muted { color: #888; }
+    .back-link { margin-bottom: 16px; display: inline-block; }
+    .check { color: #28a745; }
+    .cross { color: #dc3545; }
+    .pagination {
+      display: flex; justify-content: space-between; align-items: center;
+      margin-top: 16px; padding: 12px 0;
+    }
+    .pagination a {
+      padding: 6px 14px; background: #fff; border: 1px solid #ddd; border-radius: 4px;
+      font-size: 13px; color: #4a6fa5;
+    }
+    .pagination a:hover { background: #f8f9fa; text-decoration: none; }
+    .pagination .disabled { padding: 6px 14px; font-size: 13px; color: #ccc; }
+    .pagination .page-info { font-size: 13px; color: #888; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>RailsConsoleAI Admin</h1>
+    <a href="<%= rails_console_ai.root_path %>">Sessions</a>
+  </div>
+  <div class="container">
+    <%= yield %>
+  </div>
+</body>
+</html>