belt 0.2.19 → 0.3.1

data/lib/belt/cli/doctor_command.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'open3'
+require_relative '../../belt/inflector'
 
 module Belt
   module CLI
@@ -17,13 +18,14 @@ module Belt
 
       def self.run(args)
         verbose = args.include?('--verbose') || args.include?('-v')
+        preflight = args.include?('--preflight')
 
         if args.include?('--help') || args.include?('-h')
           puts usage
           exit 0
         end
 
-        new(verbose: verbose).run
+        new(verbose: verbose, preflight: preflight).run
       end
 
       def self.usage
@@ -33,24 +35,50 @@ module Belt
           Check system dependencies and AWS configuration for Belt.
 
           Options:
-            -v, --verbose    Show detailed output for each check
-            -h, --help       Show this help
+            -v, --verbose      Show detailed output for each check
+            --preflight        Run only deploy-critical checks (indexes, credentials)
+            -h, --help         Show this help
         USAGE
       end
 
-      def initialize(verbose: false)
+      def initialize(verbose: false, preflight: false)
         @verbose = verbose
+        @preflight = preflight
         @issues = []
         @warnings = []
       end
 
-      def run
+      def run # rubocop:disable Naming/PredicateMethod
+        if @preflight
+          run_preflight
+        else
+          run_full
+        end
+
+        @issues.empty?
+      end
+
+      # Returns true if all preflight checks pass, false otherwise.
+      def run_preflight
+        check_aws_identity_quiet
+        check_table_indexes
+        check_cognito_auth
+        return if @issues.empty?
+
+        puts "\nPreflight checks failed:\n"
+        @issues.each { |i| puts "  ✗ #{i}" }
+        puts ''
+      end
+
+      def run_full
         puts "Belt Doctor\n"
         puts "Checking your system for Belt prerequisites...\n\n"
 
         check_tools
         check_aws_credentials
         check_aws_identity
+        check_table_indexes
+        check_cognito_auth
 
         puts ''
         print_summary
@@ -132,28 +160,144 @@ module Belt
           print_ok('Authentication', "account #{account}")
           puts "         ARN: #{arn}" if @verbose
         else
-          error = output.strip
-          if error.include?('ExpiredToken') || error.include?('expired')
-            print_fail('Authentication', 'credentials expired')
-            puts '         Run: aws sso login'
-            @issues << 'AWS credentials are expired — run `aws sso login`'
-          elsif error.include?('InvalidClientTokenId') || error.include?('SignatureDoesNotMatch')
-            print_fail('Authentication', 'invalid credentials')
-            puts '         Your access key or secret is incorrect.'
-            puts '         Run: aws configure'
-            @issues << 'AWS credentials are invalid'
-          elsif error.include?('Could not connect') || error.include?('Unable to locate credentials')
-            print_fail('Authentication', 'unable to authenticate')
-            puts '         Run: aws configure sso    # or set AWS_PROFILE'
-            @issues << 'Unable to authenticate with AWS'
+          handle_aws_identity_error(output.strip)
+        end
+      end
+
+      def check_aws_identity_quiet
+        _, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        return if status.success?
+
+        @issues << 'AWS credentials invalid or expired — run `aws sso login`'
+      end
+
+      def handle_aws_identity_error(error)
+        if error.include?('ExpiredToken') || error.include?('expired')
+          print_fail('Authentication', 'credentials expired')
+          puts '         Run: aws sso login'
+          @issues << 'AWS credentials are expired — run `aws sso login`'
+        elsif error.include?('InvalidClientTokenId') || error.include?('SignatureDoesNotMatch')
+          print_fail('Authentication', 'invalid credentials')
+          puts '         Your access key or secret is incorrect.'
+          puts '         Run: aws configure'
+          @issues << 'AWS credentials are invalid'
+        elsif error.include?('Could not connect') || error.include?('Unable to locate credentials')
+          print_fail('Authentication', 'unable to authenticate')
+          puts '         Run: aws configure sso    # or set AWS_PROFILE'
+          @issues << 'Unable to authenticate with AWS'
+        else
+          print_fail('Authentication', 'failed')
+          puts "         #{error.lines.first&.strip}" if error.length.positive?
+          @issues << 'AWS authentication failed'
+        end
+      end
+
+      def check_table_indexes
+        return unless Belt.root?
+
+        models_dir = File.join(Belt.root, 'lambda/models')
+        dynamodb_tf = File.join(Belt.root, 'infrastructure/modules/app/dynamodb.tf')
+
+        return unless Dir.exist?(models_dir)
+
+        puts ''
+        puts '── Tables & Indexes ──'
+
+        unless File.exist?(dynamodb_tf)
+          print_warn('dynamodb.tf', 'not found — run `belt setup tables` to generate')
+          @warnings << 'dynamodb.tf not generated — run `belt setup tables`'
+          return
+        end
+
+        tf_content = File.read(dynamodb_tf)
+        model_files = Dir.glob(File.join(models_dir, '*.rb'))
+                         .reject { |f| File.basename(f) == 'application_record.rb' }
+
+        model_files.each do |file|
+          check_model_indexes(file, tf_content)
+        end
+      end
+
+      def check_model_indexes(file, tf_content)
+        content = File.read(file)
+        class_match = content.match(/^class\s+(\w+)\s*<\s*ApplicationRecord/)
+        return unless class_match
+
+        model_name = Belt::Inflector.underscore(class_match[1])
+        table_name = Belt::Inflector.pluralize(model_name)
+
+        # Check if table exists in dynamodb.tf
+        unless tf_content.include?("resource \"aws_dynamodb_table\" \"#{table_name}\"")
+          print_fail(table_name, 'table not in dynamodb.tf')
+          @issues << "Table '#{table_name}' missing from dynamodb.tf — run `belt setup tables`"
+          return
+        end
+
+        # Extract expected indexes from belongs_to
+        expected_indexes = extract_expected_indexes(content)
+        return if expected_indexes.empty?
+
+        # Check each expected index exists in the TF file
+        # Scope check to this table's resource block
+        table_block = tf_content[/resource "aws_dynamodb_table" "#{table_name}" \{.*?^\}/m]
+        return unless table_block
+
+        missing = []
+        expected_indexes.each do |idx|
+          if table_block.include?("name            = \"#{idx[:name]}\"")
+            print_ok(table_name, idx[:name]) if @verbose
           else
-            print_fail('Authentication', 'failed')
-            puts "         #{error.lines.first&.strip}" if error.length.positive?
-            @issues << 'AWS authentication failed'
+            missing << idx
+          end
+        end
+
+        if missing.empty?
+          print_ok(table_name, "#{expected_indexes.size} index#{'es' if expected_indexes.size > 1} configured")
+        else
+          missing.each do |idx|
+            print_fail(table_name, "missing #{idx[:name]} (required by belongs_to :#{idx[:association]})")
+            @issues << "Table '#{table_name}' missing index '#{idx[:name]}' " \
+                       '— run `belt setup tables` then `belt deploy`'
           end
         end
       end
 
+      def extract_expected_indexes(content)
+        indexes = []
+        content.lines.reject { |line| line.strip.start_with?('#') }.join
+               .scan(/belongs_to\s+:(\w+)/) do |match|
+          association_name = match[0]
+          indexes << {
+            name: "#{Belt::Inflector.classify(association_name)}Index",
+            association: association_name
+          }
+        end
+        indexes
+      end
+
+      def check_cognito_auth
+        return unless Belt.root?
+
+        routes_file = Belt.routes_file
+        return unless routes_file
+
+        content = File.read(routes_file)
+
+        # Check if any routes use auth: :cognito
+        uses_cognito = content.include?('auth: :cognito')
+        return unless uses_cognito
+
+        # Check if cognito.tf exists
+        cognito_tf = File.join(Belt.root, 'infrastructure/modules/app/cognito.tf')
+        return if File.exist?(cognito_tf)
+
+        puts ''
+        puts '── Authentication ──'
+        print_warn('Cognito', 'routes use auth: :cognito but no cognito.tf found')
+        puts '         Run: belt generate auth'
+        @warnings << 'Routes use auth: :cognito but no Cognito pool is configured — run `belt generate auth`'
+      end
+
       def print_summary
         if @issues.empty? && @warnings.empty?
           puts '✓ All checks passed — you\'re ready to belt!'

data/lib/belt/cli/generate_command.rb

@@ -15,7 +15,8 @@ module Belt
   module CLI
     class GenerateCommand
       TEMPLATE_DIR = File.expand_path('../../templates/generate', __dir__)
-      GENERATORS = %w[scaffold resource model controller environment frontend views auth].freeze
+
+      GENERATORS = %w[scaffold resource model controller environment frontend views index auth].freeze
 
       include AppDetection
 
@@ -127,6 +128,8 @@ module Belt
 
         return Belt::CLI::ViewsCommand.run(args) if generator == 'views'
 
+        return Belt::CLI::IndexCommand.run(['add'] + args) if generator == 'index'
+
         return Belt::CLI::AuthCommand.run(args) if generator == 'auth'
 
         name = args.shift
@@ -290,7 +293,9 @@ module Belt
         when 'model'
           check_model_collision! unless @force
           generate_model_standalone
-        when 'controller' then generate_controller
+        when 'controller'
+          generate_controller
+          inject_routes
         end
       end
 
@@ -351,18 +356,6 @@ module Belt
         inject_parent_associations
         sync_tables
         generate_views_if_frontend
-        puts "\n✓ Scaffold '#{@singular_name}' generated!"
-        puts "\nFiles created/updated:"
-        puts "  lambda/models/#{@singular_name}.rb"
-        puts "  lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
-        puts "  #{find_routes_file_path || 'config/routes.rb'} (updated)"
-        puts "  #{find_contracts_file_path || 'config/contracts.rb'} (updated)"
-        puts "  lambda/lib/routes/#{@app_name}_routes.rb (updated)"
-        puts "  frontend/src/pages/#{@resource_name}/ (views)" if Dir.exist?('frontend/src')
-        @references.each do |ref|
-          parent_model_path = "lambda/models/#{ref[:referenced_model]}.rb"
-          puts "  #{parent_model_path} (updated — added has_many)" if File.exist?(parent_model_path)
-        end
       end
 
       def generate_model_standalone
@@ -386,25 +379,26 @@ module Belt
 
       def inject_routes
         routes_file = find_routes_file_path
-        return unless routes_file && File.exist?(routes_file)
 
-        content = File.read(routes_file)
-        tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
+        if routes_file && File.exist?(routes_file)
+          content = File.read(routes_file)
+          tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
 
-        # If this resource has a reference to a parent that already has routes, nest it
-        parent_ref = @references.find do |ref|
-          parent_resource = Belt::Inflector.pluralize(ref[:referenced_model])
-          content.match?(/resources :#{Regexp.escape(parent_resource)}\b/)
-        end
+          # If this resource has a reference to a parent that already has routes, nest it
+          parent_ref = @references.find do |ref|
+            parent_resource = Belt::Inflector.pluralize(ref[:referenced_model])
+            content.match?(/resources :#{Regexp.escape(parent_resource)}\b/)
+          end
 
-        if parent_ref
-          inject_nested_route(content, routes_file, parent_ref, tables_arg)
+          if parent_ref
+            inject_nested_route(content, routes_file, parent_ref, tables_arg)
+          else
+            inject_top_level_route(content, routes_file, tables_arg)
+          end
         else
-          inject_top_level_route(content, routes_file, tables_arg)
+          # Legacy projects without config/routes.rb — update the manifest directly
+          inject_route_manifest
         end
-
-        # Also update route manifest
-        inject_route_manifest
       end
 
       def inject_nested_route(content, routes_file, parent_ref, tables_arg)
@@ -456,18 +450,25 @@ module Belt
         elsif content.include?('# resources :posts')
           content.sub!('# resources :posts', resource_line)
         else
-          # Find the target namespace block and insert before its closing `end`
+          # Find the target gateway (or legacy namespace) block and insert before its closing `end`
+          gateway_pattern = /^(\s*)gateway :#{Regexp.escape(@app_name)}\b[^\n]*do\s*\n(.*?)^\1end/m
           namespace_pattern = /^(\s*)namespace :#{Regexp.escape(@app_name)}\b[^\n]*do\s*\n(.*?)^\1end/m
 
-          if content.match?(namespace_pattern)
-            content.sub!(namespace_pattern) do |match|
+          target_pattern = if content.match?(gateway_pattern)
+                             gateway_pattern
+                           elsif content.match?(namespace_pattern)
+                             namespace_pattern
+                           end
+
+          if target_pattern
+            content.sub!(target_pattern) do |match|
               indent = ::Regexp.last_match(1)
               match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
             end
           else
-            single_ns_pattern = /^(\s*)namespace :\w+\b[^\n]*do\s*\n(.*?)^\1end/m
-            if content.match?(single_ns_pattern)
-              content.sub!(single_ns_pattern) do |match|
+            single_gw_pattern = /^(\s*)(?:gateway|namespace) :\w+\b[^\n]*do\s*\n(.*?)^\1end/m
+            if content.match?(single_gw_pattern)
+              content.sub!(single_gw_pattern) do |match|
                 indent = ::Regexp.last_match(1)
                 match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
               end
@@ -596,8 +597,7 @@ module Belt
           next unless File.exist?(parent_model_path)
 
           content = File.read(parent_model_path)
-          has_many_line = "  has_many :#{@resource_name}, foreign_key: '#{ref[:referenced_model]}_id', " \
-                          "index: '#{Belt::Inflector.classify(ref[:referenced_model])}Index'"
+          has_many_line = "  has_many :#{@resource_name}"
 
           next if content.include?("has_many :#{@resource_name}")
 
@@ -632,7 +632,7 @@ module Belt
         return unless Dir.exist?('frontend/src')
         return if @skip_views
 
-        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force).generate
+        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force, quiet: true).generate
       end
     end
   end

data/lib/belt/cli/index_command.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative 'tables_command'
+require_relative '../inflector'
+
+module Belt
+  module CLI
+    class IndexCommand
+      MODULE_DIR = 'infrastructure/modules/app'
+      DYNAMODB_TF = File.join(MODULE_DIR, 'dynamodb.tf')
+
+      def self.run(args)
+        action = args.shift
+
+        case action
+        when 'add', nil
+          add(args)
+        when 'remove', 'rm'
+          remove(args)
+        when '--help', '-h'
+          puts usage
+        else
+          # Treat first arg as table name if no subcommand
+          add([action] + args)
+        end
+      end
+
+      def self.usage
+        <<~USAGE
+          Usage: belt generate index <table> <IndexName> --partition-key <key> [--sort-key <key>]
+                 belt destroy index <table> <IndexName>
+
+          Add or remove a Global Secondary Index (GSI) from dynamodb.tf.
+
+          Examples:
+            belt generate index messages ConversationIndex --partition-key conversation_id
+            belt generate index messages RecentByUserIndex --partition-key user_id --sort-key created_at
+            belt destroy index messages ConversationIndex
+
+          Note: After modifying indexes, run `belt deploy` to apply changes to AWS.
+                Adding a GSI to an existing table takes ~5-10 minutes (AWS limitation).
+        USAGE
+      end
+
+      def self.add(args)
+        table, index_name, partition_key, sort_key = parse_add_args(args)
+        new(table, index_name, partition_key: partition_key, sort_key: sort_key).add
+      end
+
+      def self.remove(args)
+        table = args.shift
+        index_name = args.shift
+
+        if table.nil? || index_name.nil?
+          abort "Usage: belt destroy index <table> <IndexName>\n\n" \
+                'Example: belt destroy index messages ConversationIndex'
+        end
+
+        new(table, index_name).remove
+      end
+
+      def self.parse_add_args(args)
+        table = args.shift
+        index_name = args.shift
+        partition_key = nil
+        sort_key = nil
+
+        i = 0
+        while i < args.length
+          case args[i]
+          when '--partition-key', '-p'
+            i += 1
+            partition_key = args[i]
+          when '--sort-key', '-s'
+            i += 1
+            sort_key = args[i]
+          end
+          i += 1
+        end
+
+        if table.nil? || index_name.nil? || partition_key.nil?
+          abort "Usage: belt generate index <table> <IndexName> --partition-key <key> [--sort-key <key>]\n\n" \
+                'Example: belt generate index messages ConversationIndex --partition-key conversation_id'
+        end
+
+        [table, index_name, partition_key, sort_key]
+      end
+
+      def initialize(table, index_name, partition_key: nil, sort_key: nil)
+        @table = table
+        @index_name = index_name
+        @partition_key = partition_key
+        @sort_key = sort_key
+      end
+
+      def add
+        validate_tf_exists!
+
+        content = File.read(DYNAMODB_TF)
+        table_resource = "aws_dynamodb_table\" \"#{@table}\""
+
+        unless content.include?(table_resource)
+          abort "Error: Table '#{@table}' not found in #{DYNAMODB_TF}.\n" \
+                'Run `belt setup tables` first to generate the table.'
+        end
+
+        if content.include?("name            = \"#{@index_name}\"")
+          puts "  skip    #{@index_name} (already exists on #{@table})"
+          return
+        end
+
+        dynamo_pk = Belt::Inflector.camelize_lower(@partition_key)
+        dynamo_sk = @sort_key ? Belt::Inflector.camelize_lower(@sort_key) : nil
+
+        # Build the GSI block
+        gsi_block = build_gsi_block(dynamo_pk, dynamo_sk)
+
+        # Build attribute blocks for new keys
+        attr_blocks = build_attribute_blocks(content, dynamo_pk, dynamo_sk)
+
+        # Insert into the table resource
+        insert_gsi(content, gsi_block, attr_blocks)
+
+        puts "  create  #{@index_name} on #{@table} (partition: #{dynamo_pk}#{", sort: #{dynamo_sk}" if dynamo_sk})"
+        puts "\n  Run `belt deploy` to apply. Adding a GSI to an existing table takes ~5-10 min."
+      end
+
+      def remove
+        validate_tf_exists!
+
+        content = File.read(DYNAMODB_TF)
+
+        unless content.include?("name            = \"#{@index_name}\"")
+          abort "Error: Index '#{@index_name}' not found in #{DYNAMODB_TF}."
+        end
+
+        # Remove the GSI block
+        content.sub!(/\n\s*global_secondary_index \{\n\s*name\s*=\s*"#{Regexp.escape(@index_name)}".*?\n\s*\}/m, '')
+
+        File.write(DYNAMODB_TF, content)
+        puts "  remove  #{@index_name} from #{@table}"
+        puts "\n  Run `belt deploy` to apply."
+      end
+
+      private
+
+      def validate_tf_exists!
+        return if File.exist?(DYNAMODB_TF)
+
+        abort "Error: #{DYNAMODB_TF} not found.\nRun `belt setup tables` first."
+      end
+
+      def build_gsi_block(dynamo_pk, dynamo_sk)
+        lines = []
+        lines << '  global_secondary_index {'
+        lines << "    name            = \"#{@index_name}\""
+        lines << "    hash_key        = \"#{dynamo_pk}\""
+        lines << "    range_key       = \"#{dynamo_sk}\"" if dynamo_sk
+        lines << '    projection_type = "ALL"'
+        lines << '  }'
+        lines.join("\n")
+      end
+
+      def build_attribute_blocks(content, dynamo_pk, dynamo_sk)
+        blocks = []
+        [dynamo_pk, dynamo_sk].compact.each do |key|
+          next if content.include?("name = \"#{key}\"")
+
+          blocks << "\n  attribute {\n    name = \"#{key}\"\n    type = \"S\"\n  }"
+        end
+        blocks.join
+      end
+
+      def insert_gsi(content, gsi_block, attr_blocks)
+        # Find the table's resource block and insert before point_in_time_recovery
+        table_pattern = /resource "aws_dynamodb_table" "#{Regexp.escape(@table)}" \{.*?point_in_time_recovery/m
+
+        content.sub!(table_pattern) do |match|
+          # Insert attributes after last existing attribute block
+          unless attr_blocks.empty?
+            match.sub!(/(  attribute \{.*?\n  \})(?!.*attribute)/m) { |attr_match| "#{attr_match}#{attr_blocks}" }
+          end
+
+          # Insert GSI before point_in_time_recovery
+          match.sub('point_in_time_recovery', "#{gsi_block}\n\n  point_in_time_recovery")
+        end
+
+        File.write(DYNAMODB_TF, content)
+      end
+    end
+  end
+end

data/lib/belt/cli/lambda_config_command.rb

@@ -34,7 +34,7 @@ module Belt
       SUPPORTED_KEYS = %w[
         timeout memory_size env_vars env_keys
         s3_buckets dynamodb_tables sns_triggers sqs_triggers
-        reserved_concurrency ephemeral_storage
+        reserved_concurrency ephemeral_storage iam_policy_arns
       ].freeze
 
       def self.run(args)
@@ -112,6 +112,7 @@ module Belt
             sqs_triggers         SQS queue triggers
             reserved_concurrency Reserved concurrency limit
             ephemeral_storage    Ephemeral storage in MB (512-10240)
+            iam_policy_arns      Additional IAM policy ARNs (supports ref())
         HELP
       end
 

data/lib/belt/cli/routes_command/route_inference.rb

@@ -14,9 +14,10 @@ module Belt
           non_param = segments.reject { |s| s.start_with?(':', '{') }
           return gateway.name if non_param.empty?
 
-          # Nested resources (/posts/{id}/comments) and scoped resources (/admin/users):
-          # join non-param segments → posts/comments, admin/users
-          return non_param.map { |s| s.gsub('-', '_') }.join('/') if route.resource? && non_param.length > 1
+          # Nested resources (/posts/{id}/comments): use the last non-param segment
+          # as the controller name (matches Rails — nesting affects URL, not controller lookup).
+          # Scoped resources (/admin/users) still use the full path when controller is explicitly set.
+          return non_param.last.gsub('-', '_') if route.resource? && non_param.length > 1
 
           # For non-resource routes with a single segment (e.g., post '/signup' in :onboarding),
           # the segment is the action name, not the controller. Use the gateway name as controller.

data/lib/belt/cli/routes_command.rb

@@ -250,18 +250,8 @@ module Belt
       def output_concise(routes)
         return puts('No routes defined.') if routes.empty?
 
-        multi_gateway = routes.map { |r| r[:gateway] }.uniq.length > 1
         verb_w = [routes.map { |r| r[:verb].length }.max, 6].max
         path_w = [routes.map { |r| r[:path].length }.max, 4].max
-
-        if multi_gateway
-          output_concise_multi_gateway(routes, verb_w, path_w)
-        else
-          output_concise_single_gateway(routes, verb_w, path_w)
-        end
-      end
-
-      def output_concise_multi_gateway(routes, verb_w, path_w)
         gw_w = [routes.map { |r| r[:gateway].to_s.length }.max, 7].max
         lam_w = [routes.map { |r| r[:lambda].length }.max, 6].max
 
@@ -278,15 +268,6 @@ module Belt
         end
       end
 
-      def output_concise_single_gateway(routes, verb_w, path_w)
-        puts "#{'VERB'.ljust(verb_w)}  #{'PATH'.ljust(path_w)}  CONTROLLER#ACTION"
-        puts '-' * (verb_w + path_w + 30)
-
-        routes.each do |r|
-          puts "#{r[:verb].ljust(verb_w)}  #{r[:path].ljust(path_w)}  #{r[:controller]}##{r[:action]}"
-        end
-      end
-
       def route_specificity(path, verb)
         segments = path.split('/').reject(&:empty?)
         param_count = segments.count { |s| s.start_with?('{') }

data/lib/belt/cli/tables_command.rb

@@ -243,7 +243,9 @@ module Belt
       end
 
       def table_name(model_name)
-        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
+        # Dasherize to match ActiveItem's table_name_for convention:
+        # class_name.underscore.dasherize.pluralize
+        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name).tr('_', '-')}"
       end
     end
   end

data/lib/belt/cli/views_command.rb

@@ -75,10 +75,11 @@ module Belt
         end
       end
 
-      def initialize(name, fields, force: false)
+      def initialize(name, fields, force: false, quiet: false)
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
         @force = force
+        @quiet = quiet
         @overwrite_all = false
         @singular_name = Belt::Inflector.singularize(@name)
         @resource_name = Belt::Inflector.pluralize(@singular_name)
@@ -103,14 +104,7 @@ module Belt
 
         inject_routes
 
-        puts "\n✓ Views for '#{@singular_name}' generated!"
-        puts "\nFiles created:"
-        puts "  #{pages_dir}/#{@plural_class_name}Index.jsx"
-        puts "  #{pages_dir}/#{@class_name}Show.jsx"
-        puts "  #{pages_dir}/#{@class_name}New.jsx"
-        puts "  #{pages_dir}/#{@class_name}Edit.jsx"
-        puts "  #{pages_dir}/#{@class_name}Form.jsx"
-        puts '  frontend/src/App.jsx (updated)'
+        puts "\n✓ Views for '#{@singular_name}' generated!" unless @quiet
       end
 
       private