rails-mcp-server 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65769f824f1dbb5bfe856a40f0a46aed59d4591b3e2d23c486b6f6a08687075c
-  data.tar.gz: 596d5a5bd1d22559a0d4d9ea1369b1c375546ce790a3c71edc378c053c75b433
+  metadata.gz: 26aa11dc067437b85e216c16112efaba559848364c024682704672ec48c63cab
+  data.tar.gz: 59b0ea4590b1528ddc0eeaa94e6a876c8446a239033966ccaff5b474eda7f252
 SHA512:
-  metadata.gz: 4c51f927f27949ec313ce1762911676f338553513189f030fc610847ced95d0b1f31d8badcfafe6d89d077e15fde6b6ec2d4e9a4417afd2aaeccd3275b46c170
-  data.tar.gz: 5d290f823f45a04ef7a4e0fed4a2ec2820e6be1c086af40441dc33cba7423ac2698e58b300febe2f8cd7accbdf49e7f5663dbd38f2e4a8162d6c30b326849cc2
+  metadata.gz: eb371f905fba252428f9c2557b4cd74991c81da2f22a089f1fa54ce1ff20db53bec3177264a20dc9955f0b19790a1015b5d36f7d69c1f6556ee55faa1908606f
+  data.tar.gz: b78991e7abf1c45b15e342be60dd1f533dc7e68d1129c356940bf9088df4d2e4f66607d05e3b82b50cd83dc902eb33340723538e89aab351c0ebc80c43246deb

data/CHANGELOG.md

@@ -5,6 +5,60 @@ 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.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2025-12-19
+
+### Added
+
+- **GitHub Copilot Agent Support**: Full compatibility with GitHub Copilot coding agent
+  - New `--single-project` flag to use current directory as the only project
+  - New `RAILS_MCP_PROJECT_PATH` environment variable for explicit project path configuration
+  - Auto-detection of Rails applications from Gemfile (`gem "rails"`)
+  - Auto-detection of Rails engines from gemspec files (dependencies on `rails`, `railties`, `actionpack`, `activerecord`, etc.)
+  - Auto-switch to single project when only one project is configured in `projects.yml`
+- **Documentation**: New `docs/COPILOT_AGENT.md` with comprehensive setup guide for GitHub Copilot Agent
+
+### Changed
+
+- **Project Detection Priority**: Projects are now detected in this order:
+  1. `RAILS_MCP_PROJECT_PATH` environment variable (highest priority)
+  2. Auto-detection of Rails application from Gemfile in current directory
+  3. Auto-detection of Rails engine from gemspec in current directory
+  4. `projects.yml` configuration file (existing behavior)
+- **Error Messages**: Improved error message when no projects found to suggest running from a Rails directory
+- **load_guide Parameter Rename**: Renamed `guides` parameter to `library` for clarity
+  - Old: `execute_tool("load_guide", { guides: "rails", guide: "active_record" })`
+  - New: `execute_tool("load_guide", { library: "rails", guide: "active_record" })`
+  - The `library` parameter specifies the guide source: 'rails', 'turbo', 'stimulus', 'kamal', or 'custom'
+
+### Fixed
+
+- **execute_tool params schema**: Added `.hash` type to `params` argument so it appears in the JSON schema sent to MCP clients. Previously, tools requiring parameters (like `load_guide` with `library`) could not receive them because the `params` field was missing from the schema.
+- **Test suite stability**: Fixed ConfigTest teardown to restore a fresh Config instance instead of setting it to nil, which was causing subsequent tests to fail with `NoMethodError: undefined method 'current_project=' for nil`
+- **Rails 8.1.1 compatibility**: Fixed `analyze_controller_views` callback introspection that failed with "undefined method 'options'" error. Now uses `respond_to?(:options)` to maintain backward compatibility with both Rails 8.1+ and earlier versions.
+- **load_guide input validation**: Added validation to prevent path traversal and special characters in guide names. Guide names must now use only letters, numbers, underscores, hyphens, or forward slashes.
+- **Improved error messages**: Better error messages for unknown tools, missing models, and missing tables with helpful tips (e.g., use CamelCase for models, snake_case plural for tables)
+
+### Security
+
+- **Input validation hardening** (PR #25): Comprehensive security audit addressing CodeQL findings
+  - New `PathValidator` module centralizing all input sanitization
+  - Path traversal prevention: validates paths stay within project root
+  - Sensitive file protection: blocks access to `master.key`, `credentials.yml.enc`, `.env` files, `database.yml`
+  - Shell injection prevention: uses `IO.popen` with array arguments instead of shell interpolation
+  - SQL/code injection prevention in `get_schema`: strict alphanumeric validation for table names
+  - ReDoS fixes: replaced vulnerable regex patterns with linear-time string operations
+  - Safe YAML loading: replaced `YAML.load_file` with `YAML.safe_load_file` to prevent arbitrary object deserialization
+- **CI Security Infrastructure**:
+  - Dependabot for automated dependency updates
+  - CodeQL static analysis for vulnerability detection
+  - OpenSSF Scorecard for security best practices tracking
+  - SECURITY.md vulnerability disclosure policy
+
+### Technical
+
+- **Rails runner improvements**: Better handling of log pollution in JSON output, rbenv version selection from project's `.ruby-version`
+- **Test coverage**: 27 new tests for PathValidator security validations
+
 ## [1.4.1] - 2025-12-11
 
 ### Fixed

data/README.md

@@ -263,6 +263,79 @@ This setup allows STDIO-only clients to communicate with the Rails MCP Server th
 
 **Tip**: The `rails-mcp-config` tool can configure HTTP mode with mcp-remote automatically.
 
+## GitHub Copilot Agent Integration
+
+Rails MCP Server works with GitHub Copilot coding agent out of the box. The server auto-detects Rails projects when started from a Rails directory or when configured with environment variables.
+
+### Quick Setup
+
+1. **Configure MCP** - Create `.github/copilot/mcp.json` in your repository:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "args": ["--single-project"],
+      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
+    }
+  }
+}
+```
+
+2. **Setup Steps** - Create `.github/workflows/copilot-setup-steps.yml`:
+
+```yaml
+name: "Copilot Setup Steps"
+
+on: workflow_dispatch
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install Rails MCP Server
+        run: gem install rails-mcp-server
+```
+
+### Alternative: Environment Variable
+
+You can also use the `RAILS_MCP_PROJECT_PATH` environment variable:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "env": {
+        "RAILS_MCP_PROJECT_PATH": "."
+      },
+      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
+    }
+  }
+}
+```
+
+### Limitations
+
+- GitHub Copilot Agent only supports MCP **tools**, not resources or prompts
+- The `load_guide` analyzer works via `execute_tool`, but requires guides to be downloaded during setup
+
+For detailed instructions, see [docs/COPILOT_AGENT.md](docs/COPILOT_AGENT.md).
+
 ## How the Server Works
 
 The Rails MCP Server implements the Model Context Protocol using either:
@@ -437,10 +510,11 @@ execute_tool(tool_name: "analyze_environment_config")
 Load documentation guides from Rails, Turbo, Stimulus, Kamal, or Custom.
 
 ```
-execute_tool(tool_name: "load_guide", params: { guides: "rails" })
-execute_tool(tool_name: "load_guide", params: { guides: "rails", guide: "getting_started" })
-execute_tool(tool_name: "load_guide", params: { guides: "turbo" })
-execute_tool(tool_name: "load_guide", params: { guides: "stimulus" })
+execute_tool(tool_name: "load_guide", params: { library: "rails" })
+execute_tool(tool_name: "load_guide", params: { library: "rails", guide: "getting_started" })
+execute_tool(tool_name: "load_guide", params: { library: "turbo" })
+execute_tool(tool_name: "load_guide", params: { library: "stimulus" })
+execute_tool(tool_name: "load_guide", params: { library: "custom", guide: "tailwind" })
 ```
 
 ## Resources and Documentation
@@ -530,6 +604,10 @@ To use with an MCP client:
 2. Connect your MCP-compatible client to the server
 3. The client will be able to use the available tools to interact with your Rails projects
 
+## Security
+
+For security concerns, please see [SECURITY.md](SECURITY.md).
+
 ## License
 
 This Rails MCP server is released under the MIT License, a permissive open-source license that allows for free use, modification, distribution, and private use.

data/docs/{AGENT.md → AGENT.md}

@@ -2,6 +2,32 @@
 
 This guide helps AI agents (Claude, GPT, etc.) use the Rails MCP Server effectively. It covers tool selection, common patterns, and troubleshooting.
 
+## Architecture Overview
+
+Rails MCP Server uses a **progressive tool discovery** pattern to minimize context usage:
+
+```
+MCP Client (Claude, etc.)
+    │
+    ▼
+┌─────────────────────────────────────────────┐
+│  4 MCP-Registered Tools                     │
+│  ┌─────────────┐  ┌─────────────────────┐   │
+│  │switch_project│  │search_tools        │   │
+│  └─────────────┘  └─────────────────────┘   │
+│  ┌─────────────┐  ┌─────────────────────┐   │
+│  │execute_tool │──▶│ 9 Internal Analyzers│   │
+│  └─────────────┘  └─────────────────────┘   │
+│  ┌─────────────┐                            │
+│  │execute_ruby │                            │
+│  └─────────────┘                            │
+└─────────────────────────────────────────────┘
+```
+
+**Key concept:** Only 4 tools are registered with MCP. The 9 internal analyzers (`analyze_models`, `get_routes`, etc.) are discovered via `search_tools` and invoked via `execute_tool`.
+
+---
+
 ## Quick Start
 
 **Always start with these two steps:**
@@ -160,11 +186,11 @@ railsMcpServer:execute_tool tool_name: "analyze_controller_views" params: { cont
 ### Loading Framework Guides
 
 ```
-railsMcpServer:execute_tool tool_name: "load_guide" params: { guides: "rails", guide: "getting_started" }
-railsMcpServer:execute_tool tool_name: "load_guide" params: { guides: "rails", guide: "active_record_basics" }
-railsMcpServer:execute_tool tool_name: "load_guide" params: { guides: "turbo" }
-railsMcpServer:execute_tool tool_name: "load_guide" params: { guides: "stimulus" }
-railsMcpServer:execute_tool tool_name: "load_guide" params: { guides: "kamal" }
+railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "getting_started" }
+railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "rails", guide: "active_record_basics" }
+railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "turbo" }
+railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "stimulus" }
+railsMcpServer:execute_tool tool_name: "load_guide" params: { library: "kamal" }
 ```
 
 ---
@@ -217,6 +243,27 @@ railsMcpServer:execute_ruby code: "puts read_file('Gemfile')"
 
 ---
 
+## Analyzer Parameter Quick Reference
+
+| Analyzer | Required | Optional |
+|----------|----------|----------|
+| `project_info` | - | `max_depth`, `include_files`, `detail_level` |
+| `list_files` | - | `directory`, `pattern` |
+| `get_file` | `path` | - |
+| `get_routes` | - | `controller`, `verb`, `path_contains`, `named_only`, `detail_level` |
+| `analyze_models` | - | `model_name`, `model_names`, `detail_level`, `analysis_type` |
+| `get_schema` | - | `table_name`, `table_names`, `detail_level` |
+| `analyze_controller_views` | - | `controller_name`, `detail_level`, `analysis_type` |
+| `analyze_environment_config` | - | (none) |
+| `load_guide` | `library` | `guide` |
+
+**Common parameter values:**
+- `detail_level`: `"names"`, `"summary"`, `"full"`
+- `analysis_type`: `"introspection"`, `"static"`, `"full"`
+- `library` (for load_guide): `"rails"`, `"turbo"`, `"stimulus"`, `"kamal"`, `"custom"`
+
+---
+
 ## Rails MCP vs Claude Built-in Tools
 
 | Task | Use This | NOT This |
@@ -260,6 +307,34 @@ railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/transactions/**/*').
 
 ---
 
+## Decision Tree: Which Tool Should I Use?
+
+```
+What do you need to do?
+│
+├─► Read/analyze code?
+│   ├─► Single file? ──────────► execute_ruby with read_file()
+│   ├─► Model info? ───────────► analyze_models (params: model_name)
+│   ├─► Controller info? ──────► analyze_controller_views (params: controller_name)
+│   └─► Multiple files? ───────► execute_ruby with Dir.glob()
+│
+├─► Database info?
+│   ├─► Table structure? ──────► get_schema (params: table_name)
+│   └─► List all tables? ──────► get_schema (params: detail_level: "tables")
+│
+├─► Routing info?
+│   ├─► All routes? ───────────► get_routes
+│   └─► Filtered routes? ──────► get_routes (params: controller, verb, path_contains)
+│
+├─► Project overview? ─────────► project_info
+│
+├─► Documentation? ────────────► load_guide (params: library, guide)
+│
+└─► Custom Ruby code? ─────────► execute_ruby
+```
+
+---
+
 ## Common Pitfalls
 
 ### ❌ Don't
@@ -268,6 +343,8 @@ railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/transactions/**/*').
 - Forget `puts` in `execute_ruby` calls
 - Use absolute paths (always use paths relative to project root)
 - Skip `switch_project` before using other tools
+- Use `users` (plural) for model names - use `User` (singular CamelCase)
+- Use `User` for table names - use `users` (plural snake_case)
 
 ### ✅ Do
 
@@ -276,6 +353,8 @@ railsMcpServer:execute_ruby code: "puts Dir.glob('app/views/transactions/**/*').
 - Use `puts` to output results in `execute_ruby`
 - Fall back to `execute_ruby` when specialized tools fail
 - Use `search_tools` when unsure what's available
+- Use CamelCase singular for models: `User`, `BlogPost`, `OrderItem`
+- Use snake_case plural for tables: `users`, `blog_posts`, `order_items`
 
 ---
 

data/docs/COPILOT_AGENT.md

@@ -0,0 +1,261 @@
+# GitHub Copilot Agent Integration
+
+This guide covers how to configure Rails MCP Server for use with GitHub Copilot coding agent in your Rails projects.
+
+## Overview
+
+GitHub Copilot coding agent runs MCP servers in ephemeral GitHub Actions environments. Rails MCP Server supports this through:
+
+- **Auto-detection**: Automatically detects Rails projects in the current directory
+- **`--single-project` flag**: Explicitly uses current directory as the project
+- **`RAILS_MCP_PROJECT_PATH` env var**: Specifies project path directly
+
+## Prerequisites
+
+- A Rails application repository on GitHub
+- GitHub Copilot with coding agent enabled
+- Ruby 3.1+ (recommended: 3.3)
+
+## Configuration
+
+### Step 1: MCP Configuration
+
+Create `.github/copilot/mcp.json` in your repository:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "args": ["--single-project"],
+      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
+    }
+  }
+}
+```
+
+### Step 2: Setup Steps Workflow
+
+Create `.github/workflows/copilot-setup-steps.yml`:
+
+```yaml
+name: "Copilot Setup Steps"
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install Rails MCP Server
+        run: gem install rails-mcp-server
+
+      - name: Install project dependencies
+        run: bundle install
+```
+
+## Configuration Options
+
+### Option A: `--single-project` flag (Recommended)
+
+The simplest approach. Sets the current directory as the project:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "args": ["--single-project"]
+    }
+  }
+}
+```
+
+### Option B: Environment Variable
+
+Use `RAILS_MCP_PROJECT_PATH` for explicit path control:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "env": {
+        "RAILS_MCP_PROJECT_PATH": "."
+      }
+    }
+  }
+}
+```
+
+### Option C: Auto-Detection
+
+If the server starts from a directory containing a `Gemfile` with Rails, it auto-detects:
+
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server"
+    }
+  }
+}
+```
+
+## Available Tools
+
+GitHub Copilot Agent only supports MCP **tools**. The following are available:
+
+| Tool | Description |
+|------|-------------|
+| `switch_project` | Change active project (optional in single-project mode) |
+| `search_tools` | Discover available analyzers |
+| `execute_tool` | Invoke internal analyzers |
+| `execute_ruby` | Run sandboxed Ruby code |
+
+### Internal Analyzers (via `execute_tool`)
+
+- `project_info` - Project structure and Rails version
+- `list_files` - List files matching patterns
+- `get_file` - Read file contents
+- `get_routes` - Rails routes with filtering
+- `get_schema` - Database schema information
+- `analyze_models` - Model associations and validations
+- `analyze_controller_views` - Controller-view relationships
+- `analyze_environment_config` - Environment configuration analysis
+- `load_guide` - Load framework documentation
+
+## Limitations
+
+### MCP Resources Not Supported
+
+GitHub Copilot Agent only supports tools. MCP resources and prompts are not available. This means:
+
+- Direct resource URIs (e.g., `rails://guides/getting_started`) won't work
+- Use `execute_tool("load_guide", { library: "rails", guide: "getting_started" })` instead
+
+### Documentation Guides
+
+The `load_guide` analyzer requires guides to be downloaded. To include guides:
+
+1. Download during setup steps:
+
+```yaml
+- name: Download Rails guides
+  run: rails-mcp-server-download-resources rails
+```
+
+2. Or bundle guides in your repository under `.rails-mcp/resources/`
+
+### Network Restrictions
+
+GitHub Copilot Agent runs in a sandboxed environment with firewall restrictions. The MCP server has read-only access to the repository.
+
+## Troubleshooting
+
+### Server Fails to Start
+
+1. Verify Ruby is installed in setup steps
+2. Check that `rails-mcp-server` gem is installed
+3. Ensure the workflow runs before Copilot agent starts
+
+### Project Not Detected
+
+1. Verify `Gemfile` exists in repository root
+2. Verify `Gemfile` contains `gem "rails"` or `gem 'rails'`
+3. Try explicit `--single-project` flag
+
+### Tools Not Working
+
+1. Verify project dependencies are installed (`bundle install`)
+2. Check that the project has valid Rails structure
+3. Use `search_tools` to verify available analyzers
+
+## Example Workflow
+
+Here's a complete example for a typical Rails project:
+
+**.github/copilot/mcp.json**:
+```json
+{
+  "mcpServers": {
+    "rails": {
+      "type": "local",
+      "command": "rails-mcp-server",
+      "args": ["--single-project"],
+      "tools": ["switch_project", "search_tools", "execute_tool", "execute_ruby"]
+    }
+  }
+}
+```
+
+**.github/workflows/copilot-setup-steps.yml**:
+```yaml
+name: "Copilot Setup Steps"
+
+on: workflow_dispatch
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install Rails MCP Server
+        run: gem install rails-mcp-server
+
+      - name: Install dependencies
+        run: bundle install
+
+      - name: Setup database
+        run: bin/rails db:schema:load
+        env:
+          RAILS_ENV: test
+```
+
+## Priority Order
+
+The server uses this priority for project detection:
+
+1. `RAILS_MCP_PROJECT_PATH` environment variable (highest)
+2. Auto-detection from `Gemfile` in current directory
+3. `projects.yml` configuration file (lowest)
+
+In GitHub Copilot Agent environments, options 1 or 2 will typically be used since `projects.yml` doesn't exist.
+
+## Related Documentation
+
+- [AI Agent Guide](AGENT.md) - Comprehensive guide for AI agents
+- [Resources Guide](RESOURCES.md) - Documentation and guides management
+- [README](../README.md) - General server documentation

data/docs/RESOURCES.md

@@ -163,7 +163,7 @@ The `load_guide` tool is the primary way to access resources programmatically wi
 ### Basic Syntax
 
 ```
-load_guide guides: "category" guide: "guide_name"
+execute_tool("load_guide", { library: "category", guide: "guide_name" })
 ```
 
 ### Loading Specific Guides
@@ -295,7 +295,7 @@ Error: Source not readable: /path/to/file
 ```
 Guide 'invalid_guide' not found in Rails guides.
 ```
-**Solution**: Use `load_guide guides: "rails"` to see available guides
+**Solution**: Use `execute_tool("load_guide", { library: "rails" })` to see available guides
 
 ### Verbose Troubleshooting
 

data/exe/rails-mcp-config

@@ -20,26 +20,44 @@ module RailsMcpConfig
 
     # Catppuccin Mocha palette
     def self.green(text) = rgb(166, 227, 161, text)  # #a6e3a1
+
     def self.red(text) = rgb(243, 139, 168, text)  # #f38ba8
+
     def self.yellow(text) = rgb(249, 226, 175, text)  # #f9e2af
+
     def self.blue(text) = rgb(137, 180, 250, text)  # #89b4fa
+
     def self.mauve(text) = rgb(203, 166, 247, text)  # #cba6f7
+
     def self.teal(text) = rgb(148, 226, 213, text)  # #94e2d5
+
     def self.peach(text) = rgb(250, 179, 135, text)  # #fab387
+
     def self.pink(text) = rgb(245, 194, 231, text)  # #f5c2e7
+
     def self.sky(text) = rgb(137, 220, 235, text)  # #89dceb
+
     def self.lavender(text) = rgb(180, 190, 254, text)  # #b4befe
+
     def self.text(text) = rgb(205, 214, 244, text)  # #cdd6f4
+
     def self.subtext(text) = rgb(166, 173, 200, text)  # #a6adc8
+
     def self.overlay(text) = rgb(108, 112, 134, text)  # #6c7086
 
     # Semantic aliases
     def self.success(text) = green(text)
+
     def self.error(text) = red(text)
+
     def self.warning(text) = yellow(text)
+
     def self.info(text) = sky(text)
+
     def self.accent(text) = mauve(text)
+
     def self.bold(text) = "\e[1m#{text}\e[0m"
+
     def self.dim(text) = overlay(text)
 
     # Gum hex colors (without #)
@@ -933,7 +951,7 @@ module RailsMcpConfig
       manifest_path = File.join(config_dir, "resources", "custom", "manifest.yaml")
       if File.exist?(manifest_path)
         begin
-          manifest = YAML.load_file(manifest_path)
+          manifest = YAML.safe_load_file(manifest_path, permitted_classes: [Symbol, Time])
           if manifest && manifest["files"]
             selected.each do |name|
               manifest["files"].delete("#{name}.md")

data/exe/rails-mcp-server

@@ -29,6 +29,7 @@ if ARGV[0] == "--help" || ARGV[0] == "-h"
   puts "  --mode MODE            Server mode: http or stdio (default: stdio)"
   puts "  -p, --port PORT        Port to listen on (default: 6029)"
   puts "  --bind-all             Bind to 0.0.0.0 instead of localhost (HTTP mode only)"
+  puts "  --single-project       Use current directory as the only project (skip projects.yml)"
   puts "  version                Display version information"
   puts "  --help, -h             Display this help message"
   puts ""
@@ -36,6 +37,7 @@ if ARGV[0] == "--help" || ARGV[0] == "-h"
   puts "  #{File.basename($0)} --log-level debug -p 6060"
   puts "  #{File.basename($0)} --mode http --bind-all"
   puts "  #{File.basename($0)} --mode stdio"
+  puts "  #{File.basename($0)} --single-project"
   exit 0
 end
 
@@ -64,6 +66,9 @@ while i < ARGV.length
   when "--bind-all"
     bind_all = true
     i += 1
+  when "--single-project"
+    ENV["RAILS_MCP_PROJECT_PATH"] = Dir.pwd
+    i += 1
   else
     i += 1
   end