rails-ai-context 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03fa54ba8f83f42735ee47382cfac1c5007486dbe1287f6e06a5f5ba1c884dce
-  data.tar.gz: '082eb0840ce4d1208d2acf33ebdede21437fe743709e404b3d3d87bba53038f0'
+  metadata.gz: a4aecabdd89f6a8bb9cb32189de791a98ebe632e3dcdb7406c4ae334eda9cb71
+  data.tar.gz: 546be87729c99383fd4eed6cb94df487f106fac6035e7a683902bf764694297b
 SHA512:
-  metadata.gz: ab1c6d28c824bfcfb022178a385d158ecebcb5858eb6d2ee2e65d4b0cf032d33c314dfd9d614545c30deb20bb4d047be1f6db2e22a86818ef66ffb6fc294cdbe
-  data.tar.gz: d4318f848e29b00ef5e4f19bc918e5be03d149ec2a59597e1c7ac7497628fef8a443fefc6e96bf117fbac7d548d38c3dcd62020b4d163a7c0860f390ad38eabf
+  metadata.gz: cf2ebe640b6dcf2d98b48dac91efb7fde81804f26d3f2b71e4f6ee59de23ed10d15e4e8b0ae5a4fe6ffc5dff2d4fb6904a99e269153da9a54909050b23d7c123
+  data.tar.gz: 9f62a8d2e6a9e73fad88bf5bbf86881976f80aa687cee579b2116d26c3d3719d4bbb82e4226d6193531efe6299abeff8272eee82190fe4703efd8e427865e133

data/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2026-03-19
+
+### Added
+
+- **Detail levels on MCP tools** — `detail:"summary"`, `detail:"standard"` (default), `detail:"full"` on `rails_get_schema`, `rails_get_routes`, `rails_get_model_details`, `rails_get_controllers`. AI calls summary first, then drills down. Based on Anthropic's recommended MCP pattern.
+- **Pagination** — `limit` and `offset` parameters on schema and routes tools for apps with hundreds of tables/routes.
+- **Response size safety net** — Configurable hard cap (`max_tool_response_chars`, default 120K) on tool responses. Truncated responses include hints to use filters.
+- **Compact CLAUDE.md** — New `:compact` context mode (default) generates ≤150 lines per Claude Code's official recommendation. Contains stack overview, key models, and MCP tool usage guide.
+- **Full mode preserved** — `config.context_mode = :full` retains the existing full-dump behavior. Also available via `rails ai:context:full` or `CONTEXT_MODE=full`.
+- **`.claude/rules/` generation** — Generates quick-reference files in `.claude/rules/` for schema and models. Auto-loaded by Claude Code alongside CLAUDE.md.
+- **Cursor MDC rules** — Generates `.cursor/rules/*.mdc` files with YAML frontmatter (globs, alwaysApply). Project overview is always-on; model/controller rules auto-attach when working in matching directories. Legacy `.cursorrules` kept for backward compatibility.
+- **Windsurf 6K compliance** — `.windsurfrules` is now hard-capped at 5,800 characters (within Windsurf's 6,000 char limit). Generates `.windsurf/rules/*.md` for the new rules format.
+- **Copilot path-specific instructions** — Generates `.github/instructions/*.instructions.md` with `applyTo` frontmatter for model and controller contexts. Main `copilot-instructions.md` respects compact mode (≤500 lines).
+- **`rails ai:context:full` task** — Dedicated rake task for full context dump.
+- **Configurable limits** — `claude_max_lines` (default: 150), `max_tool_response_chars` (default: 120K).
+
+### Changed
+
+- Default `context_mode` is now `:compact` (was implicitly `:full`). Existing behavior available via `config.context_mode = :full`.
+- Tools default to `detail:"standard"` which returns bounded results, not unlimited.
+- All tools return pagination hints when results are truncated.
+- `.windsurfrules` now uses dedicated `WindsurfSerializer` instead of sharing `RulesSerializer` with Cursor.
+
 ## [0.6.0] - 2026-03-18
 
 ### Added

data/CLAUDE.md

@@ -10,7 +10,7 @@ structure to AI assistants via the Model Context Protocol (MCP).
 - `lib/rails_ai_context/introspector.rb` — Orchestrates sub-introspectors
 - `lib/rails_ai_context/introspectors/` — 27 introspectors (schema, models, routes, jobs, gems, conventions, stimulus, database_stats, controllers, views, turbo, i18n, config, active_storage, action_text, auth, api, tests, rake_tasks, assets, devops, action_mailbox, migrations, seeds, middleware, engines, multi_database)
 - `lib/rails_ai_context/tools/` — 9 MCP tools using the official mcp SDK
-- `lib/rails_ai_context/serializers/` — Output formatters (claude, rules, copilot, markdown, JSON)
+- `lib/rails_ai_context/serializers/` — Output formatters (claude, claude_rules, cursor_rules, windsurf, windsurf_rules, copilot, copilot_instructions, rules, markdown, JSON)
 - `lib/rails_ai_context/resources.rb` — MCP resources (static data AI clients read directly)
 - `lib/rails_ai_context/server.rb` — MCP server configuration (stdio + HTTP transports)
 - `lib/rails_ai_context/middleware.rb` — Rack middleware for auto-mounting MCP HTTP endpoint
@@ -32,11 +32,13 @@ structure to AI assistants via the Model Context Protocol (MCP).
 8. **Zeitwerk autoloading** — files loaded on-demand, not all upfront
 9. **Introspector presets** — `:standard` (9 core) default, `:full` (26) for power users
 10. **MCP auto-discovery** — `.mcp.json` generated by install generator
+11. **Compact by default** — context files ≤150 lines, MCP tools use `detail` parameter (summary/standard/full)
+12. **Per-tool split rules** — `.claude/rules/`, `.cursor/rules/`, `.windsurf/rules/`, `.github/instructions/`
 
 ## Testing
 
 ```bash
-bundle exec rspec           # Run specs (282 examples)
+bundle exec rspec           # Run specs (348 examples)
 bundle exec rubocop         # Lint
 ```
 

data/README.md

@@ -69,22 +69,66 @@ This creates:
 
 Each file is tailored to the AI assistant's preferred format. **Commit these files.** Your entire team gets smarter AI assistance.
 
-### 3. MCP Server (Auto-discovered)
+### 3. MCP Server
 
-The install generator creates a `.mcp.json` file that Claude Code and Cursor auto-detect — **no manual config needed**. Just open your project.
+The gem provides a live MCP server that AI clients can query on-demand for always-up-to-date introspection. Two transports are available:
 
-To start manually:
+#### Auto-discovery (recommended)
+
+The install generator creates a `.mcp.json` file in your project root:
+
+```json
+{
+  "mcpServers": {
+    "rails-ai-context": {
+      "command": "bundle",
+      "args": ["exec", "rails", "ai:serve"]
+    }
+  }
+}
+```
+
+**Claude Code** and **Cursor** auto-detect this file — no manual config needed. Just open your project and the MCP tools are available.
+
+#### Manual setup per AI client
+
+<details>
+<summary><strong>Claude Code</strong></summary>
+
+Already handled by `.mcp.json` auto-discovery. Or add manually:
 
 ```bash
-rails ai:serve
+claude mcp add rails-ai-context -- bundle exec rails ai:serve
+```
+</details>
+
+<details>
+<summary><strong>Claude Desktop</strong></summary>
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "rails-ai-context": {
+      "command": "bundle",
+      "args": ["exec", "rails", "ai:serve"],
+      "cwd": "/path/to/your/rails/app"
+    }
+  }
+}
 ```
+</details>
 
-Or configure manually in `~/.claude/claude_desktop_config.json`:
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Already handled by `.mcp.json` auto-discovery. Or add manually in Cursor Settings > MCP:
 
 ```json
 {
   "mcpServers": {
-    "my-rails-app": {
+    "rails-ai-context": {
       "command": "bundle",
       "args": ["exec", "rails", "ai:serve"],
       "cwd": "/path/to/your/rails/app"
@@ -92,6 +136,31 @@ Or configure manually in `~/.claude/claude_desktop_config.json`:
   }
 }
 ```
+</details>
+
+#### HTTP transport (for remote clients)
+
+For browser-based tools or remote AI clients, use the HTTP transport:
+
+```bash
+rails ai:serve_http
+```
+
+This starts a standalone HTTP server at `http://127.0.0.1:6029/mcp` using the Streamable HTTP transport.
+
+Or auto-mount it inside your Rails app (no separate process needed):
+
+```ruby
+# config/initializers/rails_ai_context.rb
+RailsAiContext.configure do |config|
+  config.auto_mount = true
+  config.http_path  = "/mcp"   # default
+end
+```
+
+This inserts Rack middleware that handles MCP requests at `/mcp` and passes everything else through to your Rails app.
+
+> **Note:** Both transports are **read-only** — they expose the same 9 introspection tools and never modify your application or database. The stdio transport (`ai:serve`) is recommended for local development; HTTP is for remote or programmatic access.
 
 ---
 
@@ -230,6 +299,24 @@ This gives AI assistants context about your frontend JavaScript alongside your b
 
 ---
 
+## Stack Compatibility
+
+Works with every Rails architecture — the gem auto-detects what's relevant:
+
+| Setup | Coverage | Notes |
+|-------|----------|-------|
+| Rails full-stack (ERB + Hotwire) | 27/27 | All introspectors relevant |
+| Rails + Inertia.js (React/Vue) | ~22/27 | Views/Turbo partially useful, backend fully covered |
+| Rails API + React/Next.js SPA | ~20/27 | Schema, models, routes, API, auth, jobs — all covered |
+| Rails API + mobile app | ~20/27 | Same as SPA — backend introspection is identical |
+| Rails engine (mountable gem) | ~15/27 | Core introspectors (schema, models, routes, gems) work |
+
+Introspectors that target frontend concerns (views, Turbo, Stimulus, assets) are less relevant for API-only apps, but they degrade gracefully — they simply report nothing when those features aren't present.
+
+> **Tip:** API-only apps can use the `:standard` preset (9 core introspectors) for faster introspection, or cherry-pick with `config.introspectors += %i[auth api]`. See [Configuration](#configuration).
+
+---
+
 ## Rake Tasks
 
 | Command | Description |

data/lib/generators/rails_ai_context/install/install_generator.rb

@@ -41,6 +41,17 @@ module RailsAiContext
             # Paths to exclude from code search
             # config.excluded_paths += %w[vendor/bundle]
 
+            # Context mode for generated files (CLAUDE.md, .cursorrules, etc.)
+            # :compact — smart, ≤150 lines, references MCP tools for details (default)
+            # :full    — dumps everything into context files (good for small apps <30 models)
+            # config.context_mode = :compact
+
+            # Max lines for CLAUDE.md in compact mode
+            # config.claude_max_lines = 150
+
+            # Max response size for MCP tool results (chars). Safety net for large apps.
+            # config.max_tool_response_chars = 120_000
+
             # Auto-mount HTTP MCP endpoint at /mcp
             # config.auto_mount = false
             # config.http_path  = "/mcp"
@@ -96,17 +107,21 @@ module RailsAiContext
         say "  rails ai:serve           # Start MCP server (stdio)"
         say "  rails ai:inspect         # Print introspection summary"
         say ""
-        say "Supported AI assistants:", :yellow
-        say "  Claude Code        → CLAUDE.md                        (rails ai:context:claude)"
-        say "  Cursor             → .cursorrules                     (rails ai:context:cursor)"
-        say "  Windsurf           → .windsurfrules                   (rails ai:context:windsurf)"
-        say "  GitHub Copilot     → .github/copilot-instructions.md  (rails ai:context:copilot)"
+        say "Generated files per AI tool:", :yellow
+        say "  Claude Code    → CLAUDE.md + .claude/rules/*.md"
+        say "  Cursor         → .cursorrules + .cursor/rules/*.mdc"
+        say "  Windsurf       → .windsurfrules + .windsurf/rules/*.md"
+        say "  GitHub Copilot → .github/copilot-instructions.md + .github/instructions/*.instructions.md"
         say ""
         say "MCP auto-discovery:", :yellow
         say "  .mcp.json is auto-detected by Claude Code and Cursor."
         say "  No manual MCP config needed — just open your project."
         say ""
-        say "Commit CLAUDE.md, .cursorrules, and .mcp.json so your team benefits!", :green
+        say "Context modes:", :yellow
+        say "  rails ai:context         # compact mode (default, smart for any app size)"
+        say "  rails ai:context:full    # full dump (good for small apps)"
+        say ""
+        say "Commit context files and .mcp.json so your team benefits!", :green
       end
     end
   end

data/lib/rails_ai_context/configuration.rb

@@ -33,6 +33,17 @@ module RailsAiContext
     # TTL in seconds for cached introspection (default: 30)
     attr_accessor :cache_ttl
 
+    # Context file generation mode
+    # :compact — ≤150 lines CLAUDE.md, references MCP tools for details (default)
+    # :full    — current behavior, dumps everything into context files
+    attr_accessor :context_mode
+
+    # Max lines for generated CLAUDE.md (only applies in :compact mode)
+    attr_accessor :claude_max_lines
+
+    # Max characters for any single MCP tool response (safety net)
+    attr_accessor :max_tool_response_chars
+
     def initialize
       @server_name         = "rails-ai-context"
       @server_version      = RailsAiContext::VERSION
@@ -49,7 +60,10 @@ module RailsAiContext
         ActionText::RichText ActionText::EncryptedRichText
         ActionMailbox::InboundEmail ActionMailbox::Record
       ]
-      @cache_ttl            = 30
+      @cache_ttl                = 30
+      @context_mode             = :compact
+      @claude_max_lines         = 150
+      @max_tool_response_chars  = 120_000
     end
 
     def preset=(name)

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Serializers
+    # Generates .claude/rules/ files for Claude Code auto-discovery.
+    # These provide quick-reference lists without bloating CLAUDE.md.
+    class ClaudeRulesSerializer
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      # @param output_dir [String] Rails root path
+      # @return [Hash] { written: [paths], skipped: [paths] }
+      def call(output_dir)
+        rules_dir = File.join(output_dir, ".claude", "rules")
+        FileUtils.mkdir_p(rules_dir)
+
+        written = []
+        skipped = []
+
+        files = {
+          "rails-schema.md" => render_schema_reference,
+          "rails-models.md" => render_models_reference
+        }
+
+        files.each do |filename, content|
+          next unless content
+
+          filepath = File.join(rules_dir, filename)
+          if File.exist?(filepath) && File.read(filepath) == content
+            skipped << filepath
+          else
+            File.write(filepath, content)
+            written << filepath
+          end
+        end
+
+        { written: written, skipped: skipped }
+      end
+
+      private
+
+      def render_schema_reference
+        schema = context[:schema]
+        return nil unless schema.is_a?(Hash) && !schema[:error]
+        tables = schema[:tables] || {}
+        return nil if tables.empty?
+
+        lines = [
+          "# Database Tables (#{tables.size})",
+          "",
+          "For full column details, use the `rails_get_schema` MCP tool.",
+          "Call with `detail:\"summary\"` first, then `table:\"name\"` for specifics.",
+          ""
+        ]
+
+        tables.keys.sort.each do |name|
+          data = tables[name]
+          col_count = data[:columns]&.size || 0
+          pk = data[:primary_key] || "id"
+          lines << "- #{name} (#{col_count} cols, pk: #{pk})"
+        end
+
+        lines.join("\n")
+      end
+
+      def render_models_reference
+        models = context[:models]
+        return nil unless models.is_a?(Hash) && !models[:error]
+        return nil if models.empty?
+
+        lines = [
+          "# ActiveRecord Models (#{models.size})",
+          "",
+          "For full details, use `rails_get_model_details` MCP tool.",
+          "Call with no args to list all, then `model:\"Name\"` for specifics.",
+          ""
+        ]
+
+        models.keys.sort.each do |name|
+          data = models[name]
+          assocs = (data[:associations] || []).size
+          vals = (data[:validations] || []).size
+          table = data[:table_name]
+          line = "- #{name}"
+          line += " (table: #{table})" if table
+          line += " — #{assocs} assocs, #{vals} validations"
+          lines << line
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_ai_context/serializers/claude_serializer.rb

@@ -2,9 +2,219 @@
 
 module RailsAiContext
   module Serializers
-    # Generates verbose markdown optimized for Claude Code.
-    # Includes a behavioral rules section and full detail.
-    class ClaudeSerializer < MarkdownSerializer
+    # Generates CLAUDE.md optimized for Claude Code.
+    # In :compact mode (default), produces ≤150 lines with MCP tool references.
+    # In :full mode, delegates to MarkdownSerializer with behavioral rules.
+    class ClaudeSerializer
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def call
+        if RailsAiContext.configuration.context_mode == :full
+          FullClaudeSerializer.new(context).call
+        else
+          render_compact
+        end
+      end
+
+      private
+
+      def render_compact
+        lines = []
+        lines.concat(render_header)
+        lines.concat(render_stack_overview)
+        lines.concat(render_key_models)
+        lines.concat(render_notable_gems)
+        lines.concat(render_architecture)
+        lines.concat(render_mcp_guide)
+        lines.concat(render_conventions)
+        lines.concat(render_commands)
+        lines.concat(render_footer)
+
+        # Enforce max lines
+        max = RailsAiContext.configuration.claude_max_lines
+        if lines.size > max
+          lines = lines.first(max - 2)
+          lines << ""
+          lines << "_Context trimmed. Use MCP tools for full details._"
+        end
+
+        lines.join("\n")
+      end
+
+      def render_header
+        [
+          "# #{context[:app_name]} — AI Context",
+          "",
+          "> Rails #{context[:rails_version]} | Ruby #{context[:ruby_version]}",
+          "> Generated by rails-ai-context v#{RailsAiContext::VERSION}",
+          ""
+        ]
+      end
+
+      def render_stack_overview
+        lines = [ "## Stack" ]
+
+        schema = context[:schema]
+        if schema && !schema[:error]
+          lines << "- Database: #{schema[:adapter]} — #{schema[:total_tables]} tables"
+        end
+
+        models = context[:models]
+        if models.is_a?(Hash) && !models[:error]
+          lines << "- Models: #{models.size}"
+        end
+
+        routes = context[:routes]
+        if routes && !routes[:error]
+          ctrl_count = (routes[:by_controller] || {}).keys.size
+          lines << "- Routes: #{routes[:total_routes]} across #{ctrl_count} controllers"
+        end
+
+        auth = context[:auth]
+        if auth.is_a?(Hash) && !auth[:error]
+          parts = []
+          parts << "Devise" if auth.dig(:authentication, :devise)&.any?
+          parts << "Rails 8 auth" if auth.dig(:authentication, :rails_auth)
+          parts << "Pundit" if auth.dig(:authorization, :pundit)&.any?
+          parts << "CanCanCan" if auth.dig(:authorization, :cancancan)
+          lines << "- Auth: #{parts.join(' + ')}" if parts.any?
+        end
+
+        jobs = context[:jobs]
+        if jobs.is_a?(Hash) && !jobs[:error]
+          job_count = jobs[:jobs]&.size || 0
+          mailer_count = jobs[:mailers]&.size || 0
+          channel_count = jobs[:channels]&.size || 0
+          parts = []
+          parts << "#{job_count} jobs" if job_count > 0
+          parts << "#{mailer_count} mailers" if mailer_count > 0
+          parts << "#{channel_count} channels" if channel_count > 0
+          lines << "- Async: #{parts.join(', ')}" if parts.any?
+        end
+
+        migrations = context[:migrations]
+        if migrations.is_a?(Hash) && !migrations[:error]
+          pending = migrations[:pending]
+          lines << "- Migrations: #{migrations[:total]} total, #{pending&.size || 0} pending"
+        end
+
+        lines << ""
+        lines
+      end
+
+      def render_key_models
+        models = context[:models]
+        return [] unless models.is_a?(Hash) && !models[:error] && models.any?
+
+        max_show = 15
+        lines = [ "## Key models (#{models.size} total)" ]
+        models.keys.sort.first(max_show).each do |name|
+          data = models[name]
+          assoc_count = (data[:associations] || []).size
+          val_count = (data[:validations] || []).size
+          top_assocs = (data[:associations] || []).first(3).map { |a| "#{a[:type]} :#{a[:name]}" }.join(", ")
+          line = "- **#{name}**"
+          line += " (#{assoc_count}a, #{val_count}v)" if assoc_count > 0 || val_count > 0
+          line += " — #{top_assocs}" if top_assocs && !top_assocs.empty?
+          lines << line
+        end
+        lines << "- _...#{models.size - max_show} more (use `rails_get_model_details` tool)_" if models.size > max_show
+        lines << ""
+        lines
+      end
+
+      def render_notable_gems
+        gems = context[:gems]
+        return [] unless gems.is_a?(Hash) && !gems[:error]
+        notable = gems[:notable_gems] || gems[:notable] || gems[:detected] || []
+        return [] if notable.empty?
+
+        lines = [ "## Gems" ]
+        grouped = notable.group_by { |g| g[:category]&.to_s || "other" }
+        grouped.each do |category, gem_list|
+          names = gem_list.map { |g| g[:name] }.join(", ")
+          lines << "- **#{category}**: #{names}"
+        end
+        lines << ""
+        lines
+      end
+
+      def render_architecture
+        conv = context[:conventions]
+        return [] unless conv.is_a?(Hash) && !conv[:error]
+
+        arch = conv[:architecture] || []
+        patterns = conv[:patterns] || []
+        return [] if arch.empty? && patterns.empty?
+
+        lines = [ "## Architecture" ]
+        arch.each { |p| lines << "- #{p}" }
+        patterns.first(8).each { |p| lines << "- #{p}" }
+        lines << ""
+        lines
+      end
+
+      def render_mcp_guide
+        [
+          "## MCP tools (live introspection)",
+          "",
+          "This project exposes MCP tools. Always use `detail:\"summary\"` first,",
+          "then drill into specifics with `detail:\"full\"` + a filter.",
+          "",
+          "- `rails_get_schema` — tables, columns, indexes, foreign keys",
+          "- `rails_get_model_details` — associations, validations, scopes, enums",
+          "- `rails_get_routes` — HTTP verbs, paths, controller actions",
+          "- `rails_get_controllers` — actions, filters, strong params",
+          "- `rails_get_config` — cache, session, timezone, middleware",
+          "- `rails_get_test_info` — framework, factories, CI config",
+          "- `rails_get_gems` — categorized gem analysis",
+          "- `rails_get_conventions` — architecture and design patterns",
+          "- `rails_search_code` — regex search across the codebase",
+          ""
+        ]
+      end
+
+      def render_conventions
+        conv = context[:conventions]
+        return [] unless conv.is_a?(Hash) && !conv[:error]
+
+        config_files = conv[:config_files] || []
+        return [] if config_files.empty?
+
+        lines = [ "## Key config files" ]
+        config_files.first(5).each { |f| lines << "- `#{f}`" }
+        lines << ""
+        lines
+      end
+
+      def render_commands
+        [
+          "## Commands",
+          "- `bin/dev` — start dev server",
+          "- `bundle exec rspec` — run tests",
+          "- `rails db:migrate` — run pending migrations",
+          ""
+        ]
+      end
+
+      def render_footer
+        [
+          "## Rules",
+          "- Follow existing patterns and conventions",
+          "- Use the MCP tools to check schema before writing migrations",
+          "- Match existing code style",
+          "- Run tests after changes",
+          ""
+        ]
+      end
+    end
+
+    # Internal: full-mode Claude serializer (wraps MarkdownSerializer with behavioral rules)
+    class FullClaudeSerializer < MarkdownSerializer
       private
 
       def header

data/lib/rails_ai_context/serializers/context_file_serializer.rb

@@ -4,6 +4,7 @@ module RailsAiContext
   module Serializers
     # Orchestrates writing context files to disk in various formats.
     # Supports: CLAUDE.md, .cursorrules, .windsurfrules, .github/copilot-instructions.md, JSON
+    # Also generates split rule files for AI tools that support them.
     class ContextFileSerializer
       attr_reader :context, :format
 
@@ -50,6 +51,9 @@ module RailsAiContext
           end
         end
 
+        # Generate split rule files for all AI tools that support them
+        generate_split_rules(formats, output_dir, written, skipped)
+
         { written: written, skipped: skipped }
       end
 
@@ -59,11 +63,38 @@ module RailsAiContext
         case fmt
         when :json     then JsonSerializer.new(context).call
         when :claude   then ClaudeSerializer.new(context).call
-        when :cursor, :windsurf then RulesSerializer.new(context).call
+        when :cursor   then RulesSerializer.new(context).call
+        when :windsurf then WindsurfSerializer.new(context).call
         when :copilot  then CopilotSerializer.new(context).call
         else MarkdownSerializer.new(context).call
         end
       end
+
+      def generate_split_rules(formats, output_dir, written, skipped)
+        if formats.include?(:claude)
+          result = ClaudeRulesSerializer.new(context).call(output_dir)
+          written.concat(result[:written])
+          skipped.concat(result[:skipped])
+        end
+
+        if formats.include?(:cursor)
+          result = CursorRulesSerializer.new(context).call(output_dir)
+          written.concat(result[:written])
+          skipped.concat(result[:skipped])
+        end
+
+        if formats.include?(:windsurf)
+          result = WindsurfRulesSerializer.new(context).call(output_dir)
+          written.concat(result[:written])
+          skipped.concat(result[:skipped])
+        end
+
+        if formats.include?(:copilot)
+          result = CopilotInstructionsSerializer.new(context).call(output_dir)
+          written.concat(result[:written])
+          skipped.concat(result[:skipped])
+        end
+      end
     end
   end
 end