rails-ai-context 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e6efb0468b245ebcc4945086d0091ccdf7a5df5395af4cfde7a928ec2861c93
-  data.tar.gz: f956c81dc980e2622e04d6957ad59c054e33f416f5e37eb11c8d4466c255fa00
+  metadata.gz: 04212baad7453e8371662a226fa50dfa4b65e4b611e94af22c50ab09e314d888
+  data.tar.gz: 43140d9b9f6151a4f5e72427efd8fcba0ed4a8256ed3f3c56f6a1c1ff53fd436
 SHA512:
-  metadata.gz: 4b2eeb539cff753960b5f6718c7d3e7ec476dd56440785369ed7af6d40af9aa20ea4d213ed09e1d3cfa7f94e244f7a9a15ad57385fb6ddc88e1a338bc1aedbfe
-  data.tar.gz: '099e4dee7daefb3bddad34d9b10c3a25c8d6ff906b797f1acd35f5ae17ae169b89cf954b0cc73d7ae7fc557af6e3a3c08535d2d348ce364c08647050ff9eb19b'
+  metadata.gz: 373de7c5e83e959cc64c96ab3937e9160da315c9dde34e12f2fe506f5ee6b815cbe71a49af3e6015fe0b75b89316810ff067deb0fa839a5dd4cff6836cb33f07
+  data.tar.gz: 8c9b16584f464c0603cb04f92ab8d7daf0f8dfe04f15a78e21a6089c344bcd0aedf9a6a59e748e9a90d24a356ad27f0b69cde8512aa3fd7db1995a84641e7a22

data/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.8.1] - 2026-03-19
+
+### Added
+
+- **OpenCode support** — generates `AGENTS.md` (native OpenCode context file) plus per-directory `app/models/AGENTS.md` and `app/controllers/AGENTS.md` that OpenCode auto-loads when reading files in those directories. Falls back to `CLAUDE.md` when no `AGENTS.md` exists. New command: `rails ai:context:opencode`.
+
+### Fixed
+
+- **Live reload LoadError in HTTP mode** — when `live_reload = true` and the `listen` gem was missing, the `start_http` method's rescue block (for rackup fallback) swallowed the live reload error, producing a confusing rack error instead of the correct "listen gem required" message. The rescue is now scoped to the rackup require only.
+- **Dangling @live_reload reference** — `@live_reload` was assigned before `start` was called. If `start` raised LoadError, the instance variable pointed to a non-functional object. Now only assigned after successful start.
+
 ## [0.8.0] - 2026-03-19
 
 ### 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, claude_rules, cursor_rules, windsurf, windsurf_rules, copilot, copilot_instructions, rules, markdown, JSON)
+- `lib/rails_ai_context/serializers/` — Output formatters (claude, claude_rules, opencode, 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
@@ -39,7 +39,7 @@ structure to AI assistants via the Model Context Protocol (MCP).
 ## Testing
 
 ```bash
-bundle exec rspec           # Run specs (348 examples)
+bundle exec rspec           # Run specs (373 examples)
 bundle exec rubocop         # Lint
 ```
 

data/CONTRIBUTING.md

@@ -20,8 +20,9 @@ The test suite uses [Combustion](https://github.com/pat/combustion) to boot a mi
 lib/rails_ai_context/
 ├── introspectors/     # 27 introspectors (schema, models, routes, etc.)
 ├── tools/             # 9 MCP tools with detail levels and pagination
-├── serializers/       # Per-assistant formatters (claude, cursor, windsurf, copilot, JSON)
+├── serializers/       # Per-assistant formatters (claude, opencode, cursor, windsurf, copilot, JSON)
 ├── server.rb          # MCP server setup (stdio + HTTP)
+├── live_reload.rb     # MCP live reload (file watcher + cache invalidation)
 ├── engine.rb          # Rails Engine for auto-integration
 └── configuration.rb   # User-facing config (presets, context_mode, limits)
 ```

data/README.md

@@ -65,6 +65,11 @@ your-rails-app/
 │       ├── rails-controllers.mdc                         globs: app/controllers/**
 │       └── rails-mcp-tools.mdc                           alwaysApply: true
 │
+├── ⚡ OpenCode
+│   ├── AGENTS.md                                        native OpenCode context
+│   ├── app/models/AGENTS.md                             auto-loaded when editing models
+│   └── app/controllers/AGENTS.md                        auto-loaded when editing controllers
+│
 ├── 🔵 Windsurf
 │   ├── .windsurfrules                                    ≤5,800 chars (6K limit)
 │   └── .windsurf/rules/
@@ -347,7 +352,7 @@ The gem parses `db/schema.rb` as text when no database is connected. Works in CI
 ```bash
 git clone https://github.com/crisnahine/rails-ai-context.git
 cd rails-ai-context && bundle install
-bundle exec rspec       # 350 examples
+bundle exec rspec       # 373 examples
 bundle exec rubocop     # Lint
 ```
 

data/SECURITY.md

@@ -4,9 +4,9 @@
 
 | Version | Supported          |
 |---------|--------------------|
+| 0.8.x   | :white_check_mark: |
 | 0.7.x   | :white_check_mark: |
-| 0.6.x   | :white_check_mark: |
-| < 0.6   | :x:                |
+| < 0.7   | :x:                |
 
 ## Reporting a Vulnerability
 

data/demo_script.sh

@@ -8,7 +8,7 @@ echo 'Fetching gem metadata from https://rubygems.org...'
 sleep 0.3
 echo 'Resolving dependencies...'
 sleep 0.3
-echo 'Installing rails-ai-context 0.7.1'
+echo 'Installing rails-ai-context 0.8.1'
 echo ''
 sleep 1
 
@@ -36,6 +36,8 @@ sleep 0.15
 echo '  ✅ MCP Server    Ready (stdio transport)'
 sleep 0.15
 echo '  ✅ Ripgrep       Installed (fast code search)'
+sleep 0.15
+echo '  ✅ Live reload   `listen` gem available'
 echo ''
 sleep 0.3
 printf '  \033[1;32mAI Readiness Score: 92/100\033[0m\n'
@@ -53,6 +55,12 @@ echo '  ✅ .claude/rules/rails-models.md'
 sleep 0.08
 echo '  ✅ .claude/rules/rails-mcp-tools.md'
 sleep 0.08
+echo '  ✅ AGENTS.md'
+sleep 0.08
+echo '  ✅ app/models/AGENTS.md'
+sleep 0.08
+echo '  ✅ app/controllers/AGENTS.md'
+sleep 0.08
 echo '  ✅ .cursorrules'
 sleep 0.08
 echo '  ✅ .cursor/rules/rails-project.mdc'

data/docs/GUIDE.md

@@ -125,7 +125,7 @@ end
 
 ## Generated Files
 
-`rails ai:context` generates **17 files** across all AI assistants:
+`rails ai:context` generates **20 files** across all AI assistants:
 
 ### Claude Code (4 files)
 
@@ -136,6 +136,14 @@ end
 | `.claude/rules/rails-models.md` | Model listing with associations | Auto-loaded by Claude Code alongside CLAUDE.md. |
 | `.claude/rules/rails-mcp-tools.md` | Full MCP tool reference | Parameters, detail levels, pagination, workflow guide. |
 
+### OpenCode (3 files)
+
+| File | Purpose | Notes |
+|------|---------|-------|
+| `AGENTS.md` | Main context file | Native OpenCode format. ≤150 lines in compact mode. OpenCode also reads CLAUDE.md as fallback. |
+| `app/models/AGENTS.md` | Model reference | Auto-loaded by OpenCode when reading files in `app/models/`. |
+| `app/controllers/AGENTS.md` | Controller reference | Auto-loaded by OpenCode when reading files in `app/controllers/`. |
+
 ### Cursor (5 files)
 
 | File | Purpose | Notes |
@@ -181,9 +189,10 @@ Commit **all files except `.ai-context.json`** (which is gitignored). This gives
 
 | Command | Mode | Format | Description |
 |---------|------|--------|-------------|
-| `rails ai:context` | compact | all | Generate all 17 context files |
+| `rails ai:context` | compact | all | Generate all 18 context files |
 | `rails ai:context:full` | full | all | Generate all files in full mode |
 | `rails ai:context:claude` | compact | Claude | CLAUDE.md + .claude/rules/ |
+| `rails ai:context:opencode` | compact | OpenCode | AGENTS.md + per-directory AGENTS.md |
 | `rails ai:context:cursor` | compact | Cursor | .cursorrules + .cursor/rules/ |
 | `rails ai:context:windsurf` | compact | Windsurf | .windsurfrules + .windsurf/rules/ |
 | `rails ai:context:copilot` | compact | Copilot | copilot-instructions.md + .github/instructions/ |
@@ -204,7 +213,7 @@ Commit **all files except `.ai-context.json`** (which is gitignored). This gives
 
 | Command | Description |
 |---------|-------------|
-| `rails ai:doctor` | Run 12 diagnostic checks. Reports pass/warn/fail with fix suggestions. AI readiness score (0-100). |
+| `rails ai:doctor` | Run 13 diagnostic checks. Reports pass/warn/fail with fix suggestions. AI readiness score (0-100). |
 | `rails ai:watch` | Watch for file changes and auto-regenerate context files. Requires `listen` gem. |
 | `rails ai:inspect` | Print introspection summary to stdout. Useful for debugging. |
 
@@ -715,6 +724,31 @@ config.introspectors = %i[schema models routes gems auth api]
 | `globs: ["app/models/**/*.rb"]` | When editing files matching the glob pattern |
 | `alwaysApply: false` + `description` | When the AI decides it's relevant based on description |
 
+### OpenCode
+
+**MCP config:** Add to `opencode.json`:
+
+```json
+{
+  "mcp": {
+    "rails-ai-context": {
+      "type": "local",
+      "command": ["bundle", "exec", "rails", "ai:serve"]
+    }
+  }
+}
+```
+
+**Context files loaded:**
+- `AGENTS.md` — project overview + MCP tool guide, read at conversation start
+- `app/models/AGENTS.md` — model listing, auto-loaded when agent reads model files
+- `app/controllers/AGENTS.md` — controller listing, auto-loaded when agent reads controller files
+- Falls back to `CLAUDE.md` if no `AGENTS.md` exists
+
+OpenCode uses **per-directory lazy-loading**: when the agent reads a file, it walks up the directory tree and auto-loads any `AGENTS.md` it finds. This is how split rules work — no globs or frontmatter needed.
+
+**MCP tools:** Available via `opencode.json` config above.
+
 ### Windsurf
 
 **Context files loaded:**

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

@@ -116,6 +116,7 @@ module RailsAiContext
         say ""
         say "Generated files per AI tool:", :yellow
         say "  Claude Code    → CLAUDE.md + .claude/rules/*.md"
+        say "  OpenCode       → AGENTS.md"
         say "  Cursor         → .cursorrules + .cursor/rules/*.mdc"
         say "  Windsurf       → .windsurfrules + .windsurf/rules/*.md"
         say "  GitHub Copilot → .github/copilot-instructions.md + .github/instructions/*.instructions.md"

data/lib/rails_ai_context/serializers/context_file_serializer.rb

@@ -3,13 +3,14 @@
 module RailsAiContext
   module Serializers
     # Orchestrates writing context files to disk in various formats.
-    # Supports: CLAUDE.md, .cursorrules, .windsurfrules, .github/copilot-instructions.md, JSON
+    # Supports: CLAUDE.md, AGENTS.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
 
       FORMAT_MAP = {
         claude:    "CLAUDE.md",
+        opencode:  "AGENTS.md",
         cursor:    ".cursorrules",
         windsurf:  ".windsurfrules",
         copilot:   ".github/copilot-instructions.md",
@@ -63,6 +64,7 @@ module RailsAiContext
         case fmt
         when :json     then JsonSerializer.new(context).call
         when :claude   then ClaudeSerializer.new(context).call
+        when :opencode then OpencodeSerializer.new(context).call
         when :cursor   then RulesSerializer.new(context).call
         when :windsurf then WindsurfSerializer.new(context).call
         when :copilot  then CopilotSerializer.new(context).call
@@ -89,6 +91,12 @@ module RailsAiContext
           skipped.concat(result[:skipped])
         end
 
+        if formats.include?(:opencode)
+          result = OpencodeRulesSerializer.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])

data/lib/rails_ai_context/serializers/opencode_rules_serializer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Serializers
+    # Generates per-directory AGENTS.md files for OpenCode's lazy-loading system.
+    # When OpenCode's agent reads a file, it walks up the directory tree and
+    # auto-loads any AGENTS.md it finds — acting as contextual split rules.
+    #
+    # Generated files:
+    #   app/models/AGENTS.md      — model listing, loaded when editing models
+    #   app/controllers/AGENTS.md — controller listing, loaded when editing controllers
+    class OpencodeRulesSerializer
+      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)
+        written = []
+        skipped = []
+
+        files = {
+          File.join("app", "models", "AGENTS.md") => render_models_reference,
+          File.join("app", "controllers", "AGENTS.md") => render_controllers_reference
+        }
+
+        files.each do |relative_path, content|
+          next unless content
+
+          filepath = File.join(output_dir, relative_path)
+          dir = File.dirname(filepath)
+          next unless Dir.exist?(dir)
+
+          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_models_reference
+        models = context[:models]
+        return nil unless models.is_a?(Hash) && !models[:error] && models.any?
+
+        lines = [
+          "# ActiveRecord Models (#{models.size})",
+          "",
+          "> Auto-generated by rails-ai-context. Do not edit manually.",
+          "> Use `rails_get_model_details` MCP tool for full details.",
+          ""
+        ]
+
+        models.keys.sort.first(30).each do |name|
+          data = models[name]
+          assocs = (data[:associations] || []).first(3).map { |a| "#{a[:type]} :#{a[:name]}" }.join(", ")
+          vals = (data[:validations] || []).size
+          line = "- **#{name}**"
+          line += " (table: #{data[:table_name]})" if data[:table_name]
+          line += " — #{assocs}" unless assocs.empty?
+          line += " [#{vals}v]" if vals > 0
+          lines << line
+        end
+
+        lines << "- _...#{models.size - 30} more_" if models.size > 30
+        lines << ""
+        lines << "Use `rails_get_model_details(model:\"Name\")` for associations, validations, scopes, enums."
+
+        lines.join("\n")
+      end
+
+      def render_controllers_reference
+        data = context[:controllers]
+        return nil unless data.is_a?(Hash) && !data[:error]
+        controllers = data[:controllers] || {}
+        return nil if controllers.empty?
+
+        lines = [
+          "# Controllers (#{controllers.size})",
+          "",
+          "> Auto-generated by rails-ai-context. Do not edit manually.",
+          "> Use `rails_get_controllers` MCP tool for full details.",
+          ""
+        ]
+
+        controllers.keys.sort.first(25).each do |name|
+          info = controllers[name]
+          actions = (info[:actions] || []).map { |a| a.is_a?(Hash) ? a[:name] : a }.compact.first(6)
+          line = "- **#{name}**"
+          line += " — #{actions.join(", ")}" unless actions.empty?
+          lines << line
+        end
+
+        lines << "- _...#{controllers.size - 25} more_" if controllers.size > 25
+        lines << ""
+        lines << "Use `rails_get_controllers(controller:\"Name\")` for actions, filters, strong params."
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_ai_context/serializers/opencode_serializer.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Serializers
+    # Generates AGENTS.md optimized for OpenCode.
+    # In :compact mode (default), produces ≤150 lines with MCP tool references.
+    # In :full mode, delegates to MarkdownSerializer with OpenCode header.
+    class OpencodeSerializer
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def call
+        if RailsAiContext.configuration.context_mode == :full
+          FullOpencodeSerializer.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 # rubocop:disable Metrics/MethodLength
+        [
+          "## MCP Tool Reference",
+          "",
+          "This project exposes live MCP tools. **Always start with `detail:\"summary\"`**,",
+          "then drill into specifics with a filter or `detail:\"full\"`.",
+          "",
+          "### Detail levels (schema, routes, models, controllers)",
+          "",
+          "| Level | Returns | Default limit |",
+          "|-------|---------|---------------|",
+          "| `summary` | Names + counts | 50 |",
+          "| `standard` | Names + key details | 15 (default) |",
+          "| `full` | Everything (indexes, FKs, etc.) | 5 |",
+          "",
+          "### rails_get_schema",
+          "Params: `table`, `detail`, `limit`, `offset`, `format`",
+          "- `rails_get_schema(detail:\"summary\")` — all tables with column counts",
+          "- `rails_get_schema(table:\"users\")` — full detail for one table",
+          "- `rails_get_schema(detail:\"summary\", limit:20, offset:40)` — paginate",
+          "",
+          "### rails_get_model_details",
+          "Params: `model`, `detail`",
+          "- `rails_get_model_details(detail:\"summary\")` — list all model names",
+          "- `rails_get_model_details(model:\"User\")` — associations, validations, scopes, enums, callbacks",
+          "- `rails_get_model_details(detail:\"full\")` — all models with full association lists",
+          "",
+          "### rails_get_routes",
+          "Params: `controller`, `detail`, `limit`, `offset`",
+          "- `rails_get_routes(detail:\"summary\")` — route counts per controller",
+          "- `rails_get_routes(controller:\"users\")` — routes for one controller",
+          "- `rails_get_routes(detail:\"full\", limit:50)` — full table with route names",
+          "",
+          "### rails_get_controllers",
+          "Params: `controller`, `detail`",
+          "- `rails_get_controllers(detail:\"summary\")` — names + action counts",
+          "- `rails_get_controllers(controller:\"UsersController\")` — actions, filters, strong params",
+          "",
+          "### Other tools (no detail param)",
+          "- `rails_get_config` — cache store, session, timezone, middleware, initializers",
+          "- `rails_get_test_info` — test framework, factories/fixtures, CI config, coverage",
+          "- `rails_get_gems` — notable gems categorized by function (auth, background jobs, etc.)",
+          "- `rails_get_conventions` — architecture patterns, directory structure, config files",
+          "- `rails_search_code(pattern:\"regex\", file_type:\"rb\", max_results:20)` — ripgrep search",
+          ""
+        ]
+      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 OpenCode serializer (wraps MarkdownSerializer)
+    class FullOpencodeSerializer < MarkdownSerializer
+      private
+
+      def header
+        <<~MD
+          # #{context[:app_name]} — AI Context
+
+          > Auto-generated by rails-ai-context v#{RailsAiContext::VERSION}
+          > Generated: #{context[:generated_at]}
+          > Rails #{context[:rails_version]} | Ruby #{context[:ruby_version]}
+
+          This file gives OpenCode deep context about this Rails application's
+          structure, patterns, and conventions.
+        MD
+      end
+
+      def footer
+        rules = []
+        rules << "## Behavioral Rules"
+        rules << ""
+        rules << "When working in this codebase:"
+        rules << "- Follow existing patterns and conventions detected above"
+        rules << "- Use the database schema as the source of truth for column names and types"
+        rules << "- Respect existing associations and validations when modifying models"
+        rules << "- Match the project's architecture style (#{architecture_summary})" if architecture_summary
+        rules << "- Run `bundle exec rspec` after making changes to verify correctness"
+        rules << ""
+        rules << super
+        rules.join("\n")
+      end
+
+      def architecture_summary
+        arch = context.dig(:conventions, :architecture)
+        arch&.any? ? arch.join(", ") : nil
+      end
+    end
+  end
+end

data/lib/rails_ai_context/server.rb

@@ -76,12 +76,14 @@ module RailsAiContext
       $stderr.puts "[rails-ai-context] Tools: #{TOOLS.map { |t| t.tool_name }.join(', ')}"
       maybe_start_live_reload(server)
 
-      require "rackup"
-      Rackup::Handler.default.run(rack_app, Host: config.http_bind, Port: config.http_port)
-    rescue LoadError
-      # Fallback for older rack without rackup gem
-      require "rack/handler"
-      Rack::Handler.default.run(rack_app, Host: config.http_bind, Port: config.http_port)
+      begin
+        require "rackup"
+        Rackup::Handler.default.run(rack_app, Host: config.http_bind, Port: config.http_port)
+      rescue LoadError
+        # Fallback for older rack without rackup gem
+        require "rack/handler"
+        Rack::Handler.default.run(rack_app, Host: config.http_bind, Port: config.http_port)
+      end
     end
 
     # Conditionally start live reload based on configuration.
@@ -94,9 +96,10 @@ module RailsAiContext
       return if mode == false
 
       begin
-        @live_reload = LiveReload.new(app, mcp_server)
-        @live_reload.start
-      rescue LoadError => e
+        live_reload = LiveReload.new(app, mcp_server)
+        live_reload.start
+        @live_reload = live_reload
+      rescue LoadError
         if mode == true
           raise LoadError, "Live reload requires the `listen` gem. Add to your Gemfile: gem 'listen', group: :development"
         end

data/lib/rails_ai_context/tasks/rails_ai_context.rake

@@ -4,6 +4,7 @@ ASSISTANT_TABLE = <<~TABLE
   AI Assistant       Context File                          Command
   --                 --                                    --
   Claude Code        CLAUDE.md + .claude/rules/            rails ai:context:claude
+  OpenCode           AGENTS.md                             rails ai:context:opencode
   Cursor             .cursorrules + .cursor/rules/         rails ai:context:cursor
   Windsurf           .windsurfrules + .windsurf/rules/     rails ai:context:windsurf
   GitHub Copilot     .github/copilot-instructions.md       rails ai:context:copilot
@@ -59,7 +60,7 @@ namespace :ai do
   end
 
   namespace :context do
-    { claude: "CLAUDE.md", cursor: ".cursorrules", windsurf: ".windsurfrules",
+    { claude: "CLAUDE.md", opencode: "AGENTS.md", cursor: ".cursorrules", windsurf: ".windsurfrules",
       copilot: ".github/copilot-instructions.md", json: ".ai-context.json" }.each do |fmt, file|
       desc "Generate #{file} context file"
       task fmt => :environment do

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - crisnahine
@@ -237,6 +237,8 @@ files:
 - lib/rails_ai_context/serializers/cursor_rules_serializer.rb
 - lib/rails_ai_context/serializers/json_serializer.rb
 - lib/rails_ai_context/serializers/markdown_serializer.rb
+- lib/rails_ai_context/serializers/opencode_rules_serializer.rb
+- lib/rails_ai_context/serializers/opencode_serializer.rb
 - lib/rails_ai_context/serializers/rules_serializer.rb
 - lib/rails_ai_context/serializers/windsurf_rules_serializer.rb
 - lib/rails_ai_context/serializers/windsurf_serializer.rb