rails-ai-context 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa5518e88de666f981967ae1557990aadea0804c192511c4cbf204d6b45f146
-  data.tar.gz: e39c7430277939e504aa3056ac0ac85f9f347dd008ff907627a032d7607ad21f
+  metadata.gz: 6f3efeed4bfe44c20ff766c0398b1d8a526a13c053b47d2a93d8faa320abfdda
+  data.tar.gz: 2cfe5512db995e2b08a2f9516793f1e68e787e8b76092780370ea6b04e280f69
 SHA512:
-  metadata.gz: d1709f1becfbe976d7cd7a62690e90b31dbe5d61b2d09d9c9001ec43d0ce2d344d840d310d42d65ad9c1bf86bba2a0eb3285cb88eb074e131a373904224f7813
-  data.tar.gz: 04714a3b181c91844c27b7b64ad2c2e9db963a16ae5ee037721f01afd518bad151b4d60dee8df78a69638b0fbd87af2c18288b70d14c62a72e72bd44f23f0c2d
+  metadata.gz: 4ccbff85f3a231a4c207522834387662af03240511c2bbbf491023e2b6361b68ea1e109cc3d8b383f02c9989db5542e555b6579b01037c25757acb3d84cc4525
+  data.tar.gz: 62a53606b4e98f331e716a44a8e424479e2cd61649de82814778feb1f4b3de23607f6a1f35fb6664c465fc130c9f2a140d928c6ce8864c4d4038f7ed27ddbcbc

data/CHANGELOG.md

@@ -5,6 +5,43 @@ 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.4.0] - 2026-03-18
+
+### Added
+
+- **14 new introspectors** — Controllers, Views, Turbo/Hotwire, I18n, Config, Active Storage, Action Text, Auth, API, Tests, Rake Tasks, Asset Pipeline, DevOps, Action Mailbox
+- **3 new MCP tools** — `rails_get_controllers`, `rails_get_config`, `rails_get_test_info`
+- **3 new MCP resources** — `rails://controllers`, `rails://config`, `rails://tests`
+- **Model introspector enhancements** — Extracts `has_secure_password`, `encrypts`, `normalizes`, `delegate`, `serialize`, `store`, `generates_token_for`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `broadcasts_to` via source parsing
+- **Stimulus introspector enhancements** — Extracts `outlets` and `classes` from controllers
+- **Gem introspector enhancements** — 30+ new notable gems: monitoring (Sentry, Datadog, New Relic, Skylight), admin (ActiveAdmin, Administrate, Avo), pagination (Pagy, Kaminari), search (Ransack, pg_search, Searchkick), forms (SimpleForm), utilities (Faraday, Flipper, Bullet, Rack::Attack), and more
+- **Convention detector enhancements** — Detects concerns, validators, policies, serializers, notifiers, Phlex, PWA, encrypted attributes, normalizations
+- **Markdown serializer sections** — All 14 new introspector sections rendered in generated context files
+- **Doctor enhancements** — 4 new checks: controllers, views, i18n, tests (11 total)
+- **Fingerprinter expansion** — Watches `app/controllers`, `app/views`, `app/jobs`, `app/mailers`, `app/channels`, `app/javascript/controllers`, `config/initializers`, `lib/tasks`; glob now covers `.rb`, `.rake`, `.js`, `.ts`, `.erb`, `.haml`, `.slim`, `.yml`
+
+### Fixed
+
+- **YAML parsing** — `YAML.load_file` calls now pass `permitted_classes: [Symbol], aliases: true` for Psych 4 (Ruby 3.1+) compatibility
+- **Rake task parser** — Fixed `@last_desc` instance variable leaking between files; fixed namespace tracking with indent-based stack
+- **Vite detection** — Changed `File.exist?("vite.config")` to `Dir.glob("vite.config.*")` to match `.js`/`.ts`/`.mjs` extensions
+- **Health check regex** — Added word boundaries to avoid false positives on substrings (e.g. "groups" matching "up")
+- **Multi-attribute macros** — `normalizes :email, :name` now captures all attributes, not just the first
+- **Stimulus action regex** — Requires `method(args) {` pattern to avoid matching control flow keywords
+- **Controller respond_to** — Simplified format extraction to avoid nested `end` keyword issues
+- **GetRoutes nil guard** — Added `|| {}` fallback for `by_controller` to prevent crash on partial introspection data
+- **GetSchema nil guard** — Added `|| {}` fallback for `schema[:tables]` to prevent crash on partial schema data
+- **View layout discovery** — Added `File.file?` filter to exclude directories from layout listing
+- **Fingerprinter glob** — Changed from `**/*.rb` to multi-extension glob to detect changes in `.rake`, `.js`, `.ts`, `.erb` files
+
+### Changed
+
+- Default introspectors expanded from 7 to 21
+- MCP tools expanded from 6 to 9
+- Static MCP resources expanded from 4 to 7
+- Doctor checks expanded from 7 to 11
+- Test suite expanded from 149 to 247 examples with exact value assertions
+
 ## [0.3.0] - 2026-03-18
 
 ### Added

data/CLAUDE.md

@@ -7,7 +7,7 @@ structure to AI assistants via the Model Context Protocol (MCP).
 
 - `lib/rails_ai_context.rb` — Main entry point, public API
 - `lib/rails_ai_context/introspector.rb` — Orchestrates sub-introspectors
-- `lib/rails_ai_context/introspectors/` — Individual introspectors (schema, models, routes, jobs, gems, conventions, stimulus, database_stats)
+- `lib/rails_ai_context/introspectors/` — Individual 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)
 - `lib/rails_ai_context/tools/` — MCP tools using the official mcp SDK
 - `lib/rails_ai_context/serializers/` — Output formatters (claude, rules, copilot, markdown, JSON)
 - `lib/rails_ai_context/resources.rb` — MCP resources (static data AI clients read directly)

data/README.md

@@ -6,7 +6,7 @@
 [![CI](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml/badge.svg)](https://github.com/crisnahine/rails-ai-context/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-`rails-ai-context` automatically introspects your Rails application and exposes your models, routes, schema, jobs, gems, and conventions to AI assistants through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
+`rails-ai-context` automatically introspects your Rails application and exposes your models, routes, schema, controllers, views, jobs, gems, auth, API, tests, config, and conventions to AI assistants through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
 
 **Your AI assistant instantly understands your entire Rails app. No configuration. No manual tool definitions. Just `bundle add` and go.**
 
@@ -27,12 +27,21 @@ bundle add rails-ai-context
 That's it. Now your AI assistant knows:
 
 - **Every table, column, index, and foreign key** in your database
-- **Every model** with its associations, validations, scopes, enums, and callbacks
+- **Every model** with associations, validations, scopes, enums, callbacks, and macros (has_secure_password, encrypts, normalizes, etc.)
+- **Every controller** with actions, filters, strong params, and concerns
+- **Every view** with layouts, templates, partials, helpers, and template engines
 - **Every route** with HTTP verbs, paths, and controller actions
 - **Every background job**, mailer, and Action Cable channel
-- **Every notable gem** and what it means (Devise = auth, Sidekiq = jobs, Turbo = Hotwire)
+- **Hotwire/Turbo** — Turbo Frames, Turbo Streams, model broadcasts
+- **Every notable gem** (70+) and what it means (Devise = auth, Sidekiq = jobs, Turbo = Hotwire)
+- **Auth & security** — Devise modules, Pundit policies, CanCanCan, CORS, CSP
+- **API layer** — serializers, GraphQL, versioning, rate limiting
+- **Test infrastructure** — framework, factories/fixtures, CI config, coverage
+- **Configuration** — cache store, session store, middleware, initializers
+- **Asset pipeline** — Propshaft/Sprockets, importmaps, CSS framework, JS bundler
+- **DevOps** — Puma config, Procfile, Docker, deployment tools
 - **Your architecture patterns**: service objects, STI, polymorphism, state machines, multi-tenancy
-- **Stimulus controllers** with targets, values, and actions
+- **Stimulus controllers** with targets, values, actions, outlets, and classes
 
 ---
 
@@ -85,7 +94,7 @@ Or add to your Claude Code config (`~/.claude/claude_desktop_config.json`):
 
 ## MCP Tools
 
-The gem exposes 6 tools via MCP that AI clients can call:
+The gem exposes 9 tools via MCP that AI clients can call:
 
 | Tool | Description | Annotations |
 |------|-------------|-------------|
@@ -95,6 +104,9 @@ The gem exposes 6 tools via MCP that AI clients can call:
 | `rails_get_gems` | Notable gems categorized by function with explanations | read-only, idempotent |
 | `rails_search_code` | Ripgrep-powered code search across the codebase | read-only, idempotent |
 | `rails_get_conventions` | Architecture patterns, directory structure, config files | read-only, idempotent |
+| `rails_get_controllers` | Controller actions, filters, strong params, concerns | read-only, idempotent |
+| `rails_get_config` | App configuration: cache, sessions, middleware, initializers | read-only, idempotent |
+| `rails_get_test_info` | Test framework, factories, CI config, coverage | read-only, idempotent |
 
 All tools are **read-only** — they never modify your application or database.
 
@@ -108,6 +120,9 @@ In addition to tools, the gem registers MCP resources that AI clients can read d
 | `rails://routes` | All routes (JSON) |
 | `rails://conventions` | Detected patterns and architecture (JSON) |
 | `rails://gems` | Notable gems with categories (JSON) |
+| `rails://controllers` | All controllers with actions and filters (JSON) |
+| `rails://config` | Application configuration (JSON) |
+| `rails://tests` | Test infrastructure details (JSON) |
 | `rails://models/{name}` | Per-model details (resource template) |
 
 ---
@@ -178,7 +193,7 @@ Check your app's AI readiness:
 rails ai:doctor
 ```
 
-Reports pass/warn/fail for schema, models, routes, gems, context files, MCP server, and ripgrep. Includes fix suggestions and an AI readiness score (0-100).
+Reports pass/warn/fail for schema, models, routes, gems, controllers, views, i18n, tests, context files, MCP server, and ripgrep. Includes fix suggestions and an AI readiness score (0-100).
 
 ---
 
@@ -186,8 +201,7 @@ Reports pass/warn/fail for schema, models, routes, gems, context files, MCP serv
 
 The gem automatically detects Stimulus controllers and extracts:
 - Controller names (derived from filenames)
-- Static targets
-- Static values
+- Static targets, values, outlets, and classes
 - Action methods
 
 This gives AI assistants context about your frontend JavaScript alongside your backend Ruby.

data/lib/rails_ai_context/configuration.rb

@@ -32,7 +32,7 @@ module RailsAiContext
     def initialize
       @server_name         = "rails-ai-context"
       @server_version      = RailsAiContext::VERSION
-      @introspectors       = %i[schema models routes jobs gems conventions stimulus]
+      @introspectors       = %i[schema models routes jobs gems conventions stimulus controllers views turbo i18n config active_storage action_text auth api tests rake_tasks assets devops action_mailbox]
       @excluded_paths      = %w[node_modules tmp log vendor .git]
       @auto_mount          = false
       @http_path           = "/mcp"

data/lib/rails_ai_context/doctor.rb

@@ -11,6 +11,10 @@ module RailsAiContext
       check_models
       check_routes
       check_gems
+      check_controllers
+      check_views
+      check_i18n
+      check_tests
       check_context_files
       check_mcp_buildable
       check_ripgrep
@@ -67,6 +71,45 @@ module RailsAiContext
       end
     end
 
+    def check_controllers
+      dir = File.join(app.root, "app/controllers")
+      if Dir.exist?(dir) && Dir.glob(File.join(dir, "**/*.rb")).any?
+        count = Dir.glob(File.join(dir, "**/*.rb")).size
+        Check.new(name: "Controllers", status: :pass, message: "#{count} controller files found", fix: nil)
+      else
+        Check.new(name: "Controllers", status: :warn, message: "No controller files found in app/controllers/", fix: "Generate controllers with `rails generate controller`")
+      end
+    end
+
+    def check_views
+      dir = File.join(app.root, "app/views")
+      if Dir.exist?(dir) && Dir.glob(File.join(dir, "**/*")).reject { |f| File.directory?(f) }.any?
+        count = Dir.glob(File.join(dir, "**/*")).reject { |f| File.directory?(f) }.size
+        Check.new(name: "Views", status: :pass, message: "#{count} view files found", fix: nil)
+      else
+        Check.new(name: "Views", status: :warn, message: "No view files found in app/views/", fix: "Views are generated alongside controllers")
+      end
+    end
+
+    def check_i18n
+      dir = File.join(app.root, "config/locales")
+      if Dir.exist?(dir) && Dir.glob(File.join(dir, "**/*.{yml,yaml}")).any?
+        count = Dir.glob(File.join(dir, "**/*.{yml,yaml}")).size
+        Check.new(name: "I18n", status: :pass, message: "#{count} locale files found", fix: nil)
+      else
+        Check.new(name: "I18n", status: :warn, message: "No locale files found in config/locales/", fix: "Add locale files for internationalization support")
+      end
+    end
+
+    def check_tests
+      if Dir.exist?(File.join(app.root, "spec")) || Dir.exist?(File.join(app.root, "test"))
+        framework = Dir.exist?(File.join(app.root, "spec")) ? "RSpec" : "Minitest"
+        Check.new(name: "Tests", status: :pass, message: "#{framework} test directory found", fix: nil)
+      else
+        Check.new(name: "Tests", status: :warn, message: "No test directory found", fix: "Set up tests with `rails generate rspec:install` or use default Minitest")
+      end
+    end
+
     def check_context_files
       claude_path = File.join(app.root, "CLAUDE.md")
       if File.exist?(claude_path)

data/lib/rails_ai_context/fingerprinter.rb

@@ -14,6 +14,14 @@ module RailsAiContext
 
     WATCHED_DIRS = %w[
       app/models
+      app/controllers
+      app/views
+      app/jobs
+      app/mailers
+      app/channels
+      app/javascript/controllers
+      config/initializers
+      lib/tasks
     ].freeze
 
     class << self
@@ -30,7 +38,7 @@ module RailsAiContext
           full_dir = File.join(root, dir)
           next unless Dir.exist?(full_dir)
 
-          Dir.glob(File.join(full_dir, "**/*.rb")).sort.each do |path|
+          Dir.glob(File.join(full_dir, "**/*.{rb,rake,js,ts,erb,haml,slim,yml}")).sort.each do |path|
             digest.update(File.mtime(path).to_f.to_s)
           end
         end

data/lib/rails_ai_context/introspector.rb

@@ -55,6 +55,20 @@ module RailsAiContext
       when :conventions then Introspectors::ConventionDetector.new(app)
       when :stimulus       then Introspectors::StimulusIntrospector.new(app)
       when :database_stats then Introspectors::DatabaseStatsIntrospector.new(app)
+      when :controllers    then Introspectors::ControllerIntrospector.new(app)
+      when :views          then Introspectors::ViewIntrospector.new(app)
+      when :turbo          then Introspectors::TurboIntrospector.new(app)
+      when :i18n           then Introspectors::I18nIntrospector.new(app)
+      when :config         then Introspectors::ConfigIntrospector.new(app)
+      when :active_storage then Introspectors::ActiveStorageIntrospector.new(app)
+      when :action_text    then Introspectors::ActionTextIntrospector.new(app)
+      when :auth           then Introspectors::AuthIntrospector.new(app)
+      when :api            then Introspectors::ApiIntrospector.new(app)
+      when :tests          then Introspectors::TestIntrospector.new(app)
+      when :rake_tasks     then Introspectors::RakeTaskIntrospector.new(app)
+      when :assets         then Introspectors::AssetPipelineIntrospector.new(app)
+      when :devops         then Introspectors::DevOpsIntrospector.new(app)
+      when :action_mailbox then Introspectors::ActionMailboxIntrospector.new(app)
       else
         raise ConfigurationError, "Unknown introspector: #{name}"
       end

data/lib/rails_ai_context/introspectors/action_mailbox_introspector.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Discovers Action Mailbox setup: mailbox classes, routing patterns.
+    class ActionMailboxIntrospector
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call
+        {
+          installed: defined?(ActionMailbox) ? true : false,
+          mailboxes: extract_mailboxes
+        }
+      rescue => e
+        { error: e.message }
+      end
+
+      private
+
+      def root
+        app.root.to_s
+      end
+
+      def extract_mailboxes
+        dir = File.join(root, "app/mailboxes")
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, "**/*.rb")).filter_map do |path|
+          relative = path.sub("#{dir}/", "")
+          next if relative == "application_mailbox.rb"
+
+          content = File.read(path)
+          name = File.basename(path, ".rb").camelize
+
+          routing = content.scan(/routing\s+(.+?)\s+=>\s+:(\w+)/).map do |match|
+            { pattern: match[0], action: match[1] }
+          end
+
+          { name: name, file: relative, routing: routing }
+        rescue
+          nil
+        end.sort_by { |m| m[:name] }
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/action_text_introspector.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Discovers Action Text usage: rich text fields per model.
+    class ActionTextIntrospector
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call
+        {
+          installed: defined?(ActionText) ? true : false,
+          rich_text_fields: extract_rich_text_fields
+        }
+      rescue => e
+        { error: e.message }
+      end
+
+      private
+
+      def root
+        app.root.to_s
+      end
+
+      def extract_rich_text_fields
+        models_dir = File.join(root, "app/models")
+        return [] unless Dir.exist?(models_dir)
+
+        fields = []
+        Dir.glob(File.join(models_dir, "**/*.rb")).each do |path|
+          content = File.read(path)
+          model_name = File.basename(path, ".rb").camelize
+
+          content.scan(/has_rich_text\s+:(\w+)/).each do |match|
+            fields << { model: model_name, field: match[0] }
+          end
+        end
+
+        fields.sort_by { |f| [ f[:model], f[:field] ] }
+      rescue
+        []
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/active_storage_introspector.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Discovers Active Storage usage: attachments, storage service config,
+    # direct upload detection.
+    class ActiveStorageIntrospector
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call
+        {
+          installed: defined?(ActiveStorage) ? true : false,
+          attachments: extract_attachments,
+          storage_services: extract_storage_services,
+          direct_upload: detect_direct_upload
+        }
+      rescue => e
+        { error: e.message }
+      end
+
+      private
+
+      def root
+        app.root.to_s
+      end
+
+      def extract_attachments
+        models_dir = File.join(root, "app/models")
+        return [] unless Dir.exist?(models_dir)
+
+        attachments = []
+        Dir.glob(File.join(models_dir, "**/*.rb")).each do |path|
+          content = File.read(path)
+          model_name = File.basename(path, ".rb").camelize
+
+          content.scan(/has_one_attached\s+:(\w+)/).each do |match|
+            attachments << { model: model_name, name: match[0], type: "has_one_attached" }
+          end
+
+          content.scan(/has_many_attached\s+:(\w+)/).each do |match|
+            attachments << { model: model_name, name: match[0], type: "has_many_attached" }
+          end
+        end
+
+        attachments.sort_by { |a| [ a[:model], a[:name] ] }
+      rescue
+        []
+      end
+
+      def extract_storage_services
+        config_path = File.join(root, "config/storage.yml")
+        return [] unless File.exist?(config_path)
+
+        require "yaml"
+        config = YAML.load_file(config_path, permitted_classes: [ Symbol ], aliases: true) || {}
+        config.keys.sort
+      rescue
+        []
+      end
+
+      def detect_direct_upload
+        views_dir = File.join(root, "app/views")
+        js_dir = File.join(root, "app/javascript")
+
+        [ views_dir, js_dir ].any? do |dir|
+          next false unless Dir.exist?(dir)
+          Dir.glob(File.join(dir, "**/*")).any? do |f|
+            next false if File.directory?(f)
+            File.read(f).match?(/direct.upload|DirectUpload|direct_upload/)
+          rescue
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Discovers API layer setup: api_only mode, serializers, GraphQL,
+    # versioning patterns, rate limiting.
+    class ApiIntrospector
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call
+        {
+          api_only: app.config.api_only,
+          serializers: detect_serializers,
+          graphql: detect_graphql,
+          api_versioning: detect_versioning,
+          rate_limiting: detect_rate_limiting
+        }
+      rescue => e
+        { error: e.message }
+      end
+
+      private
+
+      def root
+        app.root.to_s
+      end
+
+      def detect_serializers
+        result = {}
+
+        # Jbuilder templates
+        views_dir = File.join(root, "app/views")
+        if Dir.exist?(views_dir)
+          jbuilder_files = Dir.glob(File.join(views_dir, "**/*.jbuilder"))
+          result[:jbuilder] = jbuilder_files.size if jbuilder_files.any?
+        end
+
+        # Serializer classes (Alba, Blueprinter, JSONAPI, etc.)
+        serializers_dir = File.join(root, "app/serializers")
+        if Dir.exist?(serializers_dir)
+          files = Dir.glob(File.join(serializers_dir, "**/*.rb"))
+          result[:serializer_classes] = files.map { |f| f.sub("#{serializers_dir}/", "").sub(/\.rb\z/, "").camelize }.sort
+        end
+
+        result
+      end
+
+      def detect_graphql
+        graphql_dir = File.join(root, "app/graphql")
+        return nil unless Dir.exist?(graphql_dir)
+
+        types = Dir.glob(File.join(graphql_dir, "types/**/*.rb")).size
+        mutations = Dir.glob(File.join(graphql_dir, "mutations/**/*.rb")).size
+        queries = Dir.glob(File.join(graphql_dir, "queries/**/*.rb")).size
+
+        { types: types, mutations: mutations, queries: queries }
+      end
+
+      def detect_versioning
+        controllers_dir = File.join(root, "app/controllers")
+        return [] unless Dir.exist?(controllers_dir)
+
+        Dir.glob(File.join(controllers_dir, "api/v*/")).filter_map do |path|
+          File.basename(path)
+        end.sort
+      end
+
+      def detect_rate_limiting
+        # Rack::Attack
+        init_path = File.join(root, "config/initializers/rack_attack.rb")
+        return { rack_attack: true } if File.exist?(init_path)
+
+        # Rails 8 rate limiting
+        controllers_dir = File.join(root, "app/controllers")
+        if Dir.exist?(controllers_dir)
+          Dir.glob(File.join(controllers_dir, "**/*.rb")).each do |path|
+            content = File.read(path)
+            return { rails_rate_limiting: true } if content.match?(/rate_limit\b/)
+          rescue
+            next
+          end
+        end
+
+        {}
+      end
+    end
+  end
+end

data/lib/rails_ai_context/introspectors/asset_pipeline_introspector.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # Discovers asset pipeline configuration: Propshaft/Sprockets,
+    # importmap pins, CSS framework, JS bundler.
+    class AssetPipelineIntrospector
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call
+        {
+          pipeline: detect_pipeline,
+          importmap_pins: extract_importmap_pins,
+          css_framework: detect_css_framework,
+          js_bundler: detect_js_bundler,
+          manifest_files: detect_manifests
+        }
+      rescue => e
+        { error: e.message }
+      end
+
+      private
+
+      def root
+        app.root.to_s
+      end
+
+      def detect_pipeline
+        lock_content = read_gemfile_lock
+        return "propshaft" if lock_content&.include?("propshaft (")
+        return "sprockets" if lock_content&.include?("sprockets (")
+        "none"
+      end
+
+      def extract_importmap_pins
+        path = File.join(root, "config/importmap.rb")
+        return [] unless File.exist?(path)
+
+        content = File.read(path)
+        content.scan(/pin\s+["']([^"']+)["']/).flatten.sort
+      rescue
+        []
+      end
+
+      def detect_css_framework
+        lock_content = read_gemfile_lock
+        return nil unless lock_content
+
+        return "tailwindcss" if lock_content.include?("tailwindcss-rails (")
+        return "bootstrap" if lock_content.include?("bootstrap (") || package_json_has?("bootstrap")
+        return "bulma" if package_json_has?("bulma")
+        nil
+      end
+
+      def detect_js_bundler
+        return "importmap" if File.exist?(File.join(root, "config/importmap.rb"))
+        return "esbuild" if package_json_has?("esbuild")
+        return "webpack" if File.exist?(File.join(root, "config/webpack")) || package_json_has?("webpack")
+        return "vite" if Dir.glob(File.join(root, "vite.config.*")).any?
+        return "rollup" if package_json_has?("rollup")
+        nil
+      end
+
+      def detect_manifests
+        manifests = []
+        manifests << "manifest.js" if File.exist?(File.join(root, "app/assets/config/manifest.js"))
+        manifests << "package.json" if File.exist?(File.join(root, "package.json"))
+        manifests << "importmap.rb" if File.exist?(File.join(root, "config/importmap.rb"))
+        manifests
+      end
+
+      def read_gemfile_lock
+        path = File.join(root, "Gemfile.lock")
+        File.exist?(path) ? File.read(path) : nil
+      rescue
+        nil
+      end
+
+      def package_json_has?(package)
+        path = File.join(root, "package.json")
+        return false unless File.exist?(path)
+        File.read(path).include?("\"#{package}\"")
+      rescue
+        false
+      end
+    end
+  end
+end