lcp 0.1.0

data/lib/generators/lcp_ruby/install_generator.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include FormatSupport
+
+      source_root File.expand_path("templates/install", __dir__)
+
+      desc "Sets up LCP Ruby in an existing Rails application"
+
+      class_option :skip_sample, type: :boolean, default: false,
+        desc: "Skip creating sample item model"
+
+      class_option :active_storage, type: :boolean, default: true,
+        desc: "Install Active Storage migrations (idempotent — skipped if already present)"
+
+      class_option :menu_layout, type: :string, default: "both", enum: %w[top sidebar both],
+        desc: "Menu layout sections to seed (top, sidebar, or both — default: both). " \
+              "Seeds `# lcp:menu <section>` insertion markers for `rails g lcp_ruby:entity --menu=...`."
+
+      class_option :locale, type: :string, default: nil,
+        desc: "Comma-separated locales the host app declares (e.g. 'cs' or 'cs,en,de'). " \
+              "When set, i18n_check.locales in the generated initializer mirrors this list. " \
+              "Auto-passed by `lcp new --locale=...`; safe to omit for standalone install."
+
+      def add_lcp_ruby_require
+        app_file = "config/application.rb"
+        full_path = File.join(destination_root, app_file)
+        return unless File.exist?(full_path)
+        return if File.read(full_path).include?('require "lcp_ruby"')
+
+        inject_into_file app_file, after: /Bundler\.require\(\*Rails\.groups\)\n/ do
+          "require \"lcp_ruby\"\n"
+        end
+      end
+
+      def add_autoloader_ignore
+        app_file = "config/application.rb"
+        full_path = File.join(destination_root, app_file)
+        return unless File.exist?(full_path)
+
+        content = File.read(full_path)
+        return if content.include?("ignore_lcp_services")
+
+        inject_into_file app_file, before: /^  end\nend\s*\z/ do
+          <<~RUBY.indent(4)
+
+            initializer "\#{Rails.application.class.module_parent_name.underscore}.ignore_lcp_services", before: :set_autoload_paths do
+              %w[condition_services lcp_services actions event_handlers renderers].each do |dir|
+                path = Rails.root.join("app", dir)
+                Rails.autoloaders.main.ignore(path) if path.directory?
+              end
+            end
+          RUBY
+        end
+      end
+
+      def mount_engine
+        route 'mount LcpRuby::Engine => "/"'
+      end
+
+      def create_directory_structure
+        %w[models presenters permissions views].each do |dir|
+          empty_directory "config/lcp_ruby/#{dir}"
+        end
+      end
+
+      def create_sample_model
+        return if options[:skip_sample]
+
+        copy_dsl_or_yaml "model.rb",
+          dsl_target: "config/lcp_ruby/models/item.rb",
+          yaml_target: "config/lcp_ruby/models/item.yml"
+      end
+
+      def create_sample_presenter
+        return if options[:skip_sample]
+
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target: "config/lcp_ruby/presenters/items.rb",
+          yaml_target: "config/lcp_ruby/presenters/items.yml"
+      end
+
+      def create_sample_permissions
+        return if options[:skip_sample]
+
+        template "permissions.yml", "config/lcp_ruby/permissions/item.yml"
+      end
+
+      def create_sample_view_group
+        return if options[:skip_sample]
+
+        copy_dsl_or_yaml "view_group.rb",
+          dsl_target: "config/lcp_ruby/views/items.rb",
+          yaml_target: "config/lcp_ruby/views/items.yml"
+      end
+
+      def create_default_permissions
+        template "default_permissions.yml", "config/lcp_ruby/permissions/_default.yml"
+      end
+
+      # Ships a `config/lcp_ruby/menu.yml` with the auto-populated
+      # `top_menu:` slot plus a fully-commented user-menu block. The
+      # block is opt-in: configurators uncomment after running
+      # `rails generate lcp_ruby:install_auth` (which wires Devise
+      # and the engine routes the block references). Without auth,
+      # the comments document the shape so the configurator
+      # discovers the capability when they need it.
+      def create_default_menu
+        template "menu.yml.tt", "config/lcp_ruby/menu.yml"
+      end
+
+      def create_initializer
+        initializer_path = "config/initializers/lcp_ruby.rb"
+        full_path = File.join(destination_root, initializer_path)
+        return if File.exist?(full_path)
+
+        # Parser literal MUST stay byte-identical to app_template.rb
+        # (drift test: locale_parser_drift_spec.rb). Can't share via require —
+        # app_template.rb runs before Bundler loads the gem's lib/.
+        # `.present?` (not `if options[:locale]`) — Thor passes empty --locale=
+        # through as truthy "", which would otherwise yield broken locales: [].
+        i18n_check_locales = if options[:locale].present?
+          options[:locale].split(",").map(&:strip).reject(&:empty?).uniq.map(&:to_sym)
+        else
+          [ :en ]
+        end
+
+        create_file initializer_path, <<~RUBY
+          # frozen_string_literal: true
+
+          LcpRuby.configure do |config|
+            # Authentication mode: :none, :built_in, or :external
+            #   :none      — no auth required; ApplicationController exposes a
+            #                stub current_user with role "admin" (see the
+            #                ApplicationController file). Suitable for prototypes.
+            #   :built_in  — set automatically by `rails generate lcp_ruby:install_auth`
+            #                (Devise-based; flips this line and removes the stub).
+            #   :external  — host app provides current_user (Devise, Sorcery, custom).
+            config.authentication = :none
+
+            # User class name (default: "User")
+            # config.user_class = "User"
+
+            # Role method on user object (default: :lcp_role)
+            # config.role_method = :lcp_role
+
+            # Where users land after hitting "/" (defaults to first menu item alphabetically).
+            #   String form:  config.landing_page = "dashboard"
+            #   Per-role:     config.landing_page = { "admin" => "admin-home", "default" => "dashboard" }
+            # See docs/reference/engine-configuration.md#landing_page
+            # config.landing_page = nil
+
+            # Type-driven renderer defaults: when true, presenter columns
+            # whose `renderer:` is absent get the type-driven default at
+            # runtime (e.g. :boolean → boolean_icon, :enum → badge,
+            # :text → truncate). Decision 14 in
+            # docs/design/type_system_defaults.md. New apps default this to
+            # true; existing apps upgrading should flip after auditing
+            # their hand-written index columns.
+            config.runtime_type_renderers = true
+
+            # i18n_check (rake lcp_ruby:i18n_check) — boot-time lint that
+            # asserts every labeled metadata element has a translation
+            # in every locale below. See docs/reference/i18n_check.md.
+            #
+            # Locales: list ONLY the locales this app actually ships.
+            # Without this, the lint walks I18n.available_locales which on
+            # rails-i18n hosts is ~30 entries and produces unreadable
+            # `missing in: en,ar,de,...` reports.
+            #
+            # Three offense kinds, each with its own severity:
+            #   * literal_in_dsl       — hardcoded label paired with an
+            #                            i18n key that's missing in some
+            #                            locale. Real broken-UX bug → :error.
+            #   * direct_render_label  — hardcoded label on a surface the
+            #                            runtime renders directly without
+            #                            an i18n lookup (column / filter /
+            #                            view-group view labels, …). No
+            #                            quick fix today → :warning.
+            #   * missing_translation  — humanize-default fallback would
+            #                            render in some locale → :warning
+            #                            so the initial cleanup ramp
+            #                            doesn't freeze every PR.
+            config.i18n_check = {
+              locales: #{i18n_check_locales.inspect},
+              severity_per_kind: {
+                literal_in_dsl:       :error,
+                direct_render_label:  :warning,
+                missing_translation:  :warning
+              }
+            }
+          end
+
+          # Auto-discover custom actions, event handlers, and condition services
+          # from app/actions/, app/event_handlers/, and app/condition_services/.
+          # `on_models_loaded` re-fires on every `LcpRuby.reload!` (autoreload
+          # in dev), so the registries stay populated after metadata reloads;
+          # `Rails.application.config.after_initialize` would only run once
+          # per process boot.
+          LcpRuby.on_models_loaded do
+            app_path = Rails.root.join("app")
+            LcpRuby::Actions::ActionRegistry.discover!(app_path.to_s)
+            LcpRuby::Events::HandlerRegistry.discover!(app_path.to_s)
+          end
+        RUBY
+      end
+
+      def add_current_user_helper
+        controller_path = "app/controllers/application_controller.rb"
+        full_path = File.join(destination_root, controller_path)
+        return unless File.exist?(full_path)
+        return if File.read(full_path).include?("current_user")
+
+        inject_into_class controller_path, "ApplicationController" do
+          <<~RUBY.indent(2)
+            # TODO: Replace with real authentication
+            # Run: rails generate lcp_ruby:install_auth
+            def current_user
+              @current_user ||= OpenStruct.new(id: 1, lcp_role: ["admin"], name: "Admin User")
+            end
+            helper_method :current_user
+
+          RUBY
+        end
+      end
+
+      # Active Storage backs the `attachment` field type and `rich_text` content,
+      # both of which are core to LCP. Auto-invoke is idempotent: if Active Storage
+      # migrations already exist, the call is skipped.
+      #
+      # Opt out with `--no-active-storage` if the host application uses external
+      # storage (e.g. a custom gem) or doesn't need attachments at all.
+      def install_active_storage
+        return unless options[:active_storage]
+
+        if active_storage_already_installed?
+          say_status :skip, "active_storage:install (migrations already present)"
+          return
+        end
+
+        say_status :run, "active_storage:install"
+        invoke_active_storage_install!
+      end
+
+      # `no_commands` keeps these helpers off the Thor task list (otherwise
+      # any public method on a generator becomes an auto-run command).
+      no_commands do
+        def active_storage_already_installed?
+          migration_dir = File.join(destination_root, "db/migrate")
+          return false unless Dir.exist?(migration_dir)
+
+          Dir.glob(File.join(migration_dir, "*active_storage*.rb")).any?
+        end
+
+        def invoke_active_storage_install!
+          rails_command "active_storage:install", abort_on_failure: false
+        end
+      end
+
+      # Agent affordances: copies the lcp-* skills and writes CLAUDE.md/AGENTS.md
+      # so AI agents (Claude Code, Codex, …) have orientation + authoring skills.
+      # Passive — no runtime impact. Idempotent via the managed-block strategy.
+      # Invoked in-process (not a `generate` subprocess) so it shares this run's
+      # destination_root and stays robust in tests/host apps alike. Explicit
+      # empty args avoid bleeding install's options into the sibling generator.
+      def setup_agent_affordances
+        invoke "lcp_ruby:agent_setup", [], {}
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby installed!", :green
+        say ""
+        unless options[:skip_sample]
+          say "Sample files:"
+          say "  config/lcp_ruby/models/item.#{format_extension}"
+          say "  config/lcp_ruby/presenters/items.#{format_extension}"
+          say "  config/lcp_ruby/permissions/item.yml"
+          say "  config/lcp_ruby/views/items.#{format_extension}"
+          say ""
+        end
+        say "Tip: a commented user-menu block has been added to " \
+            "config/lcp_ruby/menu.yml. Run `rails generate lcp_ruby:install_auth` " \
+            "to auto-activate it (with Devise sign-out wired in), or " \
+            "uncomment manually after wiring up your auth routes."
+        say ""
+        say "Next steps:"
+        say "  1. rails db:prepare"
+        say "  2. rails s"
+        say "  3. Visit http://localhost:3000/items"
+        say ""
+        say "Add features with generators:"
+        say "  rails generate lcp_ruby:install_auth      # Devise authentication"
+        say "  rails generate lcp_ruby:auditing          # Audit trail"
+        say "  rails generate lcp_ruby:export            # Data export"
+        say "  rails generate lcp_ruby:import            # Data import"
+        say "  rails generate lcp_ruby:custom_fields     # Runtime field definitions"
+        say "  rails generate lcp_ruby:saved_filters     # Saved search filters"
+        say "  rails generate lcp_ruby:monitoring        # Error dashboard"
+        say "  rails generate lcp_ruby:batch_operations  # Bulk operations"
+        say "  rails generate lcp_ruby:background_jobs   # Job tracking"
+        say "  rails generate lcp_ruby:pages             # DB-backed pages"
+        say "  rails generate lcp_ruby:groups            # User groups"
+        say "  rails generate lcp_ruby:role_model        # DB-backed roles"
+        say "  rails generate lcp_ruby:permission_source # Dynamic permissions"
+        say "  rails generate lcp_ruby:workflow_definition   # Workflows"
+        say "  rails generate lcp_ruby:workflow_approvals    # Approval processes"
+        say "  rails generate lcp_ruby:workflow_audit_log    # Workflow audit"
+        say "  rails generate lcp_ruby:gapfree_sequences     # Sequential numbering"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/lcp_ruby/monitoring_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    class MonitoringGenerator < Rails::Generators::Base
+      include FormatSupport
+      source_root File.expand_path("templates/monitoring", __dir__)
+
+      desc "Generates metadata files for monitoring (error log model, presenter, permissions, dashboard page)"
+
+      def copy_error_log_model
+        copy_dsl_or_yaml "model.rb",
+          dsl_target: "config/lcp_ruby/models/lcp_error_log.rb",
+          yaml_target: "config/lcp_ruby/models/lcp_error_log.yml"
+      end
+
+      def copy_error_log_presenter
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target: "config/lcp_ruby/presenters/lcp_error_logs.rb",
+          yaml_target: "config/lcp_ruby/presenters/lcp_error_logs.yml"
+      end
+
+      def copy_error_log_permissions
+        template "permissions.yml", "config/lcp_ruby/permissions/lcp_error_log.yml"
+      end
+
+      def copy_monitoring_dashboard
+        template "page.yml", "config/lcp_ruby/pages/monitoring_dashboard.yml"
+      end
+
+      def copy_model_extension
+        template "model_extension.rb", "app/model_extensions/lcp_error_log_extension.rb"
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby monitoring installed!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Restart server to create the error log table"
+        say "  2. Navigate to /monitoring for the dashboard"
+        say "  3. Navigate to /error-logs to browse errors"
+        say ""
+        say "Optional:"
+        say "  - Add 'prometheus-client' gem for Prometheus metrics"
+        say "  - Configure error_log_rate_limit in LcpRuby.configure"
+        say "  - Register the model extension in config/initializers/lcp_ruby.rb:"
+        say "    LcpRuby.configure do |c|"
+        say "      c.on_model_ready('lcp_error_log') { |m| m.include(LcpErrorLogExtension) }"
+        say "    end"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/lcp_ruby/oidc_role_mappings_generator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "yaml"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    # Generates the model, presenter, permission, and locale files needed by
+    # `role_source: db` (Phase 2). When the host has at least one OIDC
+    # provider configured with `role_source: db`, running this generator (and
+    # `db:prepare`) is what activates DB-backed role mapping.
+    #
+    # Mirrors the api_tokens generator pattern: DSL by default, `--format=yaml`
+    # for YAML mode; permissions and locales are always YAML.
+    class OidcRoleMappingsGenerator < Rails::Generators::Base
+      include FormatSupport
+      source_root File.expand_path("templates/oidc_role_mappings", __dir__)
+
+      desc "Generates metadata files for the oidc_role_mapping model and admin presenter (used by role_source: db)."
+
+      def copy_model
+        copy_dsl_or_yaml "model.rb",
+          dsl_target:  "config/lcp_ruby/models/oidc_role_mapping.rb",
+          yaml_target: "config/lcp_ruby/models/oidc_role_mapping.yml"
+      end
+
+      def copy_presenter
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target:  "config/lcp_ruby/presenters/oidc_role_mappings.rb",
+          yaml_target: "config/lcp_ruby/presenters/oidc_role_mappings.yml"
+      end
+
+      def copy_permissions
+        template "permissions.yml", "config/lcp_ruby/permissions/oidc_role_mapping.yml"
+      end
+
+      def copy_locale
+        template "locales.en.yml", "config/locales/lcp_ruby/oidc_role_mappings.en.yml"
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby OIDC role mappings installed!", :green
+        say ""
+        say "Generated files:"
+        say "  - config/lcp_ruby/models/oidc_role_mapping.#{format_extension}"
+        say "  - config/lcp_ruby/presenters/oidc_role_mappings.#{format_extension}"
+        say "  - config/lcp_ruby/permissions/oidc_role_mapping.yml"
+        say "  - config/locales/lcp_ruby/oidc_role_mappings.en.yml"
+        say ""
+        say "Next steps:"
+        say "  1. Set role_source: db on at least one OIDC provider in auth.yml."
+        say "  2. bundle exec rails db:prepare    # creates lcp_ruby_oidc_role_mappings table"
+        say "  3. Start server, sign in as an admin, manage rows at /oidc-role-mappings."
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/lcp_ruby/pages_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    class PagesGenerator < Rails::Generators::Base
+      include FormatSupport
+      source_root File.expand_path("templates/pages", __dir__)
+
+      desc "Generates metadata files for the page_config model, presenter, permissions, and view group"
+
+      def copy_model
+        copy_dsl_or_yaml "model.rb",
+          dsl_target: "config/lcp_ruby/models/page_config.rb",
+          yaml_target: "config/lcp_ruby/models/page_config.yml"
+      end
+
+      def copy_presenter
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target: "config/lcp_ruby/presenters/page_configs.rb",
+          yaml_target: "config/lcp_ruby/presenters/page_configs.yml"
+      end
+
+      def copy_permissions
+        template "permissions.yml", "config/lcp_ruby/permissions/page_config.yml"
+      end
+
+      def copy_view_group
+        copy_dsl_or_yaml "view_group.rb",
+          dsl_target: "config/lcp_ruby/views/page_configs.rb",
+          yaml_target: "config/lcp_ruby/views/page_configs.yml"
+      end
+
+      def update_initializer
+        initializer_path = "config/initializers/lcp_ruby.rb"
+        return unless File.exist?(initializer_path)
+
+        content = File.read(initializer_path)
+        return if content.include?("page_source")
+
+        inject_into_file initializer_path, after: /LcpRuby\.configure do \|config\|.*\n/ do
+          "  config.page_source = :model\n"
+        end
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby page source model installed!", :green
+        say ""
+        say "Generated files:"
+        say "  - config/lcp_ruby/models/page_config.#{format_extension}"
+        say "  - config/lcp_ruby/presenters/page_configs.#{format_extension}"
+        say "  - config/lcp_ruby/permissions/page_config.yml"
+        say "  - config/lcp_ruby/views/page_configs.#{format_extension}"
+        say ""
+        say "Next steps:"
+        say "  1. Add config.page_source = :model to your initializer (if not auto-injected)"
+        say "  2. Start server:    rails s"
+        say "  3. Navigate to /page-configs to manage page definitions"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/lcp_ruby/permission_source_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    class PermissionSourceGenerator < Rails::Generators::Base
+      include FormatSupport
+      source_root File.expand_path("templates/permission_source", __dir__)
+
+      desc "Generates metadata files for the permission_config model, presenter, permissions, and view group"
+
+      def copy_model
+        copy_dsl_or_yaml "model.rb",
+          dsl_target: "config/lcp_ruby/models/permission_config.rb",
+          yaml_target: "config/lcp_ruby/models/permission_config.yml"
+      end
+
+      def copy_presenter
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target: "config/lcp_ruby/presenters/permission_configs.rb",
+          yaml_target: "config/lcp_ruby/presenters/permission_configs.yml"
+      end
+
+      def copy_permissions
+        template "permissions.yml", "config/lcp_ruby/permissions/permission_config.yml"
+      end
+
+      def copy_view_group
+        copy_dsl_or_yaml "view_group.rb",
+          dsl_target: "config/lcp_ruby/views/permission_configs.rb",
+          yaml_target: "config/lcp_ruby/views/permission_configs.yml"
+      end
+
+      def update_initializer
+        initializer_path = "config/initializers/lcp_ruby.rb"
+        return unless File.exist?(initializer_path)
+
+        content = File.read(initializer_path)
+        return if content.include?("permission_source")
+
+        inject_into_file initializer_path, after: /LcpRuby\.configure do \|config\|.*\n/ do
+          "  config.permission_source = :model\n"
+        end
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby permission source model installed!", :green
+        say ""
+        say "Generated files:"
+        say "  - config/lcp_ruby/models/permission_config.#{format_extension}"
+        say "  - config/lcp_ruby/presenters/permission_configs.#{format_extension}"
+        say "  - config/lcp_ruby/permissions/permission_config.yml"
+        say "  - config/lcp_ruby/views/permission_configs.#{format_extension}"
+        say ""
+        say "Next steps:"
+        say "  1. Add config.permission_source = :model to your initializer (if not auto-injected)"
+        say "  2. Start server:    rails s"
+        say "  3. Navigate to /permission-configs to manage permission definitions"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/lcp_ruby/role_model_generator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require_relative "format_support"
+
+module LcpRuby
+  module Generators
+    class RoleModelGenerator < Rails::Generators::Base
+      include FormatSupport
+      source_root File.expand_path("templates/role_model", __dir__)
+
+      desc "Generates metadata files for a DB-backed role model and enables role_source: :model"
+
+      def copy_model
+        copy_dsl_or_yaml "model.rb",
+          dsl_target: "config/lcp_ruby/models/role.rb",
+          yaml_target: "config/lcp_ruby/models/role.yml"
+      end
+
+      def copy_presenter
+        copy_dsl_or_yaml "presenter.rb",
+          dsl_target: "config/lcp_ruby/presenters/roles.rb",
+          yaml_target: "config/lcp_ruby/presenters/roles.yml"
+      end
+
+      def copy_permissions
+        template "permissions.yml", "config/lcp_ruby/permissions/role.yml"
+      end
+
+      def copy_view_group
+        copy_dsl_or_yaml "view_group.rb",
+          dsl_target: "config/lcp_ruby/views/roles.rb",
+          yaml_target: "config/lcp_ruby/views/roles.yml"
+      end
+
+      def update_lcp_ruby_initializer
+        initializer_path = "config/initializers/lcp_ruby.rb"
+
+        unless File.exist?(Rails.root.join(initializer_path))
+          create_file initializer_path, <<~RUBY
+            # frozen_string_literal: true
+
+            LcpRuby.configure do |config|
+              config.role_source = :model
+            end
+          RUBY
+          return
+        end
+
+        inject_into_file initializer_path, after: "LcpRuby.configure do |config|\n" do
+          "  config.role_source = :model\n"
+        end
+      end
+
+      def show_post_install_message
+        say ""
+        say "LCP Ruby role model installed!", :green
+        say ""
+        say "Generated files:"
+        say "  - config/lcp_ruby/models/role.#{format_extension}"
+        say "  - config/lcp_ruby/presenters/roles.#{format_extension}"
+        say "  - config/lcp_ruby/permissions/role.yml"
+        say "  - config/lcp_ruby/views/roles.#{format_extension}"
+        say ""
+        say "Next steps:"
+        say "  1. Start server:    rails s"
+        say "  2. Navigate to the Roles section in your app to create roles"
+        say "  3. Role names must match those used in your permissions YAML files"
+        say ""
+      end
+    end
+  end
+end