belt 0.2.10 → 0.2.12

data/lib/belt/cli/destroy_command.rb

@@ -44,10 +44,11 @@ module Belt
         when 'environment'
           name = args.shift
           if name.nil? || name.empty?
-            puts 'Usage: belt destroy environment <name>'
+            puts 'Usage: belt destroy environment <name> [--force] [--skip-terraform]'
             exit 1
           end
-          new(generator, name, []).destroy
+          flags = parse_environment_flags(args)
+          new(generator, name, [], **flags).destroy
         when 'frontend'
           new(generator, nil, []).destroy
         when 'views'
@@ -67,6 +68,19 @@ module Belt
         end
       end
 
+      def self.parse_environment_flags(args)
+        flags = { force: false, skip_terraform: false }
+        args.each do |arg|
+          case arg
+          when '--force', '-f'
+            flags[:force] = true
+          when '--skip-terraform'
+            flags[:skip_terraform] = true
+          end
+        end
+        flags
+      end
+
       def self.parse_field(arg)
         name, type = arg.split(':', 2)
         { name: name, type: type || 'string' }
@@ -84,26 +98,37 @@ module Belt
             resource      Alias for scaffold
             model         Remove an ActiveItem model
             controller    Remove a controller
-            environment   Remove a deployment environment directory
+            environment   Remove a deployment environment and tear down infrastructure
             frontend      Remove the frontend/ directory
             views         Remove React pages for a resource
 
+          Environment options:
+            --force, -f          Skip all prompts (CI mode)
+            --skip-terraform     Delete local files without running terraform destroy
+
           Examples:
             belt d scaffold post title:string body:text status:string
             belt d model user
             belt d controller comments
             belt d environment staging
+            belt d environment dev --skip-terraform
+            belt d environment dev --force
             belt d frontend
             belt d views post
 
           ⚠ This is destructive. Files will be permanently deleted.
+
+          For environments: if terraform state is detected, you'll be prompted to run
+          `terraform destroy` first to tear down cloud resources before removing files.
         HELP
       end
 
-      def initialize(generator, name, fields)
+      def initialize(generator, name, fields, force: false, skip_terraform: false)
         @generator = generator
         @name = name&.downcase&.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
+        @force = force
+        @skip_terraform = skip_terraform
         @app_name = detect_namespace
         @singular_name = @name ? Belt::Inflector.singularize(@name) : nil
         @resource_name = @singular_name ? Belt::Inflector.pluralize(@singular_name) : nil
@@ -149,15 +174,173 @@ module Belt
 
       def destroy_environment
         dir = "infrastructure/#{@name}"
-        if Dir.exist?(dir)
-          FileUtils.rm_rf(dir)
-          @removed << dir
-          puts "  remove  #{dir}/"
-          puts "\n✓ Environment '#{@name}' destroyed!"
-        else
+
+        unless Dir.exist?(dir)
           puts "✗ Environment '#{@name}' not found at #{dir}/"
           exit 1
         end
+
+        # Check if terraform state exists (infra may still be live)
+        if !@skip_terraform && terraform_state_exists?(dir)
+          puts "⚠  Environment '#{@name}' appears to have active infrastructure."
+          puts "   Terraform state was found — resources may still be running.\n\n"
+
+          if @force
+            puts '   --force passed, skipping terraform destroy.'
+          else
+            puts '   Options:'
+            puts '     1) Run `terraform destroy` to tear down infrastructure first (recommended)'
+            puts '     2) Skip terraform and just delete the local files (--skip-terraform)'
+            puts "     3) Cancel\n\n"
+
+            print "   Run terraform destroy for '#{@name}'? [y/N/skip] "
+            response = $stdin.gets&.strip&.downcase
+
+            case response
+            when 'y', 'yes'
+              run_terraform_destroy(dir)
+            when 'skip', 's'
+              puts '   Skipping terraform destroy.'
+            else
+              puts 'Cancelled.'
+              exit 0
+            end
+          end
+        end
+
+        # Final confirmation before deleting files
+        unless @force
+          print "\nPermanently delete #{dir}/? [y/N] "
+          response = $stdin.gets&.strip&.downcase
+          unless response&.start_with?('y')
+            puts 'Cancelled.'
+            exit 0
+          end
+        end
+
+        FileUtils.rm_rf(dir)
+        @removed << dir
+        puts "  remove  #{dir}/"
+        puts "\n✓ Environment '#{@name}' destroyed!"
+      end
+
+      def terraform_state_exists?(dir)
+        # Check for local .terraform directory (initialized state)
+        return true if Dir.exist?(File.join(dir, '.terraform'))
+
+        # Check if backend.tf exists (remote state configured)
+        backend_file = File.join(dir, 'backend.tf')
+        return false unless File.exist?(backend_file)
+
+        # Try to query remote state — if terraform is initialized and state exists,
+        # the environment likely has live resources
+        Dir.chdir(dir) do
+          # Quick check: does `terraform show` return anything?
+          output = `terraform show -no-color 2>&1`
+          Process.last_status.success? && !output.strip.empty? && !output.include?('No state')
+        end
+      rescue StandardError
+        # If we can't determine state, assume it might exist and warn
+        true
+      end
+
+      def run_terraform_destroy(dir)
+        puts "\n━━━ terraform destroy (#{@name}) ━━━"
+
+        Dir.chdir(dir) do
+          # Initialize if needed
+          unless Dir.exist?('.terraform')
+            puts '  Initializing terraform...'
+            unless system('terraform', 'init', '-input=false')
+              puts "\n✗ terraform init failed. You may need to destroy manually:"
+              puts "  cd #{dir} && terraform init && terraform destroy"
+              exit 1
+            end
+          end
+
+          # Empty S3 buckets before destroy — terraform can't delete non-empty buckets
+          empty_s3_buckets_in_state
+
+          # Run destroy with auto-approve (user already confirmed)
+          unless system('terraform', 'destroy', '-auto-approve')
+            puts "\n✗ terraform destroy failed."
+            puts '  Infrastructure may still be running. Fix and retry, or use --skip-terraform.'
+            exit 1
+          end
+        end
+
+        puts '  ✓ Infrastructure destroyed.'
+      end
+
+      def empty_s3_buckets_in_state
+        output = `terraform state list 2>/dev/null`
+        return unless Process.last_status.success?
+
+        bucket_resources = output.lines.map(&:strip).grep(/\Aaws_s3_bucket\./)
+        return if bucket_resources.empty?
+
+        bucket_resources.each do |resource|
+          bucket_name = resolve_bucket_name(resource)
+          next unless bucket_name
+
+          empty_s3_bucket(bucket_name)
+        end
+      end
+
+      def resolve_bucket_name(resource)
+        output = `terraform state show '#{resource}' 2>/dev/null`
+        return nil unless Process.last_status.success?
+
+        match = output.match(/^\s*bucket\s*=\s*"([^"]+)"/)
+        match&.[](1)
+      end
+
+      def empty_s3_bucket(bucket_name)
+        # Check if bucket exists
+        `aws s3api head-bucket --bucket '#{bucket_name}' 2>&1`
+        return unless Process.last_status.success?
+
+        puts "  Emptying S3 bucket: #{bucket_name}"
+
+        # Delete all object versions (handles versioned buckets)
+        `aws s3 rm 's3://#{bucket_name}' --recursive 2>/dev/null`
+
+        # Also delete versioned objects and delete markers
+        delete_all_versions(bucket_name)
+      end
+
+      def delete_all_versions(bucket_name)
+        loop do
+          output = `aws s3api list-object-versions --bucket '#{bucket_name}' --max-items 1000 2>/dev/null`
+          break unless Process.last_status.success?
+
+          begin
+            data = JSON.parse(output)
+          rescue JSON::ParserError
+            break
+          end
+
+          versions = (data['Versions'] || []) + (data['DeleteMarkers'] || [])
+          break if versions.empty?
+
+          # Build delete objects payload
+          objects = versions.map do |v|
+            { 'Key' => v['Key'], 'VersionId' => v['VersionId'] }
+          end
+
+          delete_payload = JSON.generate({ 'Objects' => objects, 'Quiet' => true })
+
+          # Use a temp file for the payload since it can be large
+          require 'tempfile'
+          Tempfile.create(['delete-objects', '.json']) do |f|
+            f.write(delete_payload)
+            f.flush
+            `aws s3api delete-objects --bucket '#{bucket_name}' --delete 'file://#{f.path}' 2>/dev/null`
+          end
+
+          # If there's no next token, we're done
+          break unless data['NextToken'] || data['IsTruncated']
+        end
       end
 
       def destroy_frontend

data/lib/belt/cli/environment_command.rb

@@ -32,6 +32,7 @@ module Belt
         @domain = domain
         @quiet = quiet
         @announce = announce
+        @state_bucket = resolve_state_bucket
       end
 
       def generate
@@ -80,6 +81,37 @@ module Belt
         content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
         File.write(dest_path, content)
       end
+
+      # Resolve the state bucket name to use in backend.tf.
+      # Priority: existing sibling backend.tf → AWS account ID → bare placeholder.
+      def resolve_state_bucket
+        bucket_from_sibling || bucket_from_aws || 'belt-terraform-state'
+      end
+
+      def bucket_from_sibling
+        Dir.glob('infrastructure/*/backend.tf').each do |f|
+          match = File.read(f).match(/bucket\s*=\s*"([^"]+)"/)
+          next unless match
+          # Skip the bare placeholder — it means state wasn't set up yet
+          return match[1] unless match[1] == 'belt-terraform-state'
+        end
+        nil
+      end
+
+      def bucket_from_aws
+        require 'open3'
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        return nil unless status.success?
+
+        data = begin
+          JSON.parse(output)
+        rescue StandardError
+          nil
+        end
+        return nil unless data&.dig('Account')
+
+        "belt-terraform-state-#{data['Account']}"
+      end
     end
   end
 end

data/lib/belt/cli/generate_command.rb

@@ -38,8 +38,8 @@ module Belt
             Creates:
               lambda/models/<name>.rb                            Model with validations and fields
               lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
-              config/routes.tf.rb                                Route entry added
-              config/schema.tf.rb                                API response contract added
+              config/routes.rb                                   Route entry added
+              config/contracts.rb                                API response contract added
               lambda/lib/routes/<app>_routes.rb                  Route manifest updated
               infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
               frontend/src/pages/<names>/                        React pages (if frontend exists)
@@ -60,7 +60,7 @@ module Belt
           notes: <<~NOTES
             Creates:
               lambda/models/<name>.rb                            Model class inheriting from ApplicationRecord
-              config/schema.tf.rb                                API response contract added
+              config/contracts.rb                                API response contract added
               infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
           NOTES
         },
@@ -333,8 +333,8 @@ module Belt
         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.tf.rb'} (updated)"
-        puts "  #{find_schema_file_path || 'config/schema.tf.rb'} (updated)"
+        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')
       end

data/lib/belt/cli/new_command.rb

@@ -167,8 +167,8 @@ module Belt
           'lambda/controllers/application_controller.rb.erb' =>
             "#{@app_name}/lambda/controllers/api/application_controller.rb",
           'lambda/lib/routes/routes.rb.erb' => "#{@app_name}/lambda/lib/routes/api_routes.rb",
-          'config/routes.tf.rb.erb' => "#{@app_name}/config/routes.tf.rb",
-          'config/schema.tf.rb.erb' => "#{@app_name}/config/schema.tf.rb",
+          'config/routes.rb.erb' => "#{@app_name}/config/routes.rb",
+          'config/contracts.rb.erb' => "#{@app_name}/config/contracts.rb",
           'config/lambda/api.yml.erb' => "#{@app_name}/config/lambda/api.yml",
           'README.md.erb' => "#{@app_name}/README.md",
           'AGENTS.md.erb' => "#{@app_name}/AGENTS.md",

data/lib/belt/cli/plugin_command.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+
+module Belt
+  module CLI
+    # Scaffold a new Belt plugin gem (similar to `rails plugin new`).
+    #
+    # Usage:
+    #   belt plugin new messaging
+    #   belt plugin new belt-pay --path ~/code
+    #
+    # Creates a gem that registers with Belt's GeneratorRegistry via:
+    #   lib/belt/generators/<name>_generator.rb
+    class PluginCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/plugin', __dir__)
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'new'
+          new(args).generate
+        when nil, '--help', '-h', 'help'
+          print_help
+        else
+          puts "Unknown plugin subcommand: #{subcommand}"
+          puts ''
+          print_help
+          exit 1
+        end
+      end
+
+      def self.print_help
+        puts <<~HELP
+          Manage Belt plugin gems.
+
+          Usage:
+            belt plugin new <name> [options]
+
+          Arguments:
+            name                    Plugin name (e.g. messaging, pay, or belt-messaging)
+
+          Options:
+            --path DIR              Parent directory for the gem (default: current directory)
+            --summary TEXT          Short gem summary for the gemspec
+            --force                 Overwrite files if the directory already exists
+            -h, --help              Show this help
+
+          Examples:
+            belt plugin new messaging
+            belt plugin new pay --path ~/Code
+            belt plugin new belt-notifications --summary "Push notifications for Belt apps"
+
+          What you get:
+            A standalone gem (belt-<name>) with:
+              - Module under Belt::<Name>
+              - Generator at lib/belt/generators/<name>_generator.rb
+              - Configuration stub, version, RSpec, README, AGENTS.md
+              - Hooked into `belt generate <name>` / `belt destroy <name>` once
+                the gem is in an app's Gemfile
+
+          Reference plugins:
+            belt-messaging  — SMS via AWS End User Messaging
+            belt-pay        — Stripe payments and subscriptions
+
+          See the Belt README (Plugins / Contributing) and AGENTS.md for the full guide.
+        HELP
+      end
+
+      def initialize(args)
+        @raw_name = nil
+        @path = Dir.pwd
+        @summary = nil
+        @force = false
+
+        i = 0
+        while i < args.length
+          arg = args[i]
+          case arg
+          when '--path'
+            i += 1
+            @path = args[i] || Dir.pwd
+          when /^--path=/
+            @path = arg.split('=', 2).last
+          when '--summary'
+            i += 1
+            @summary = args[i]
+          when /^--summary=/
+            @summary = arg.split('=', 2).last
+          when '--force'
+            @force = true
+          when '--help', '-h'
+            self.class.print_help
+            exit 0
+          else
+            if arg.start_with?('-')
+              puts "Unknown option: #{arg}"
+              exit 1
+            end
+            @raw_name ||= arg
+          end
+          i += 1
+        end
+      end
+
+      def generate
+        if @raw_name.nil? || @raw_name.strip.empty?
+          puts 'Usage: belt plugin new <name> [options]'
+          puts "Run 'belt plugin --help' for more information."
+          exit 1
+        end
+
+        normalize_names!
+
+        if Dir.exist?(@gem_dir) && !@force
+          puts "✗ Directory already exists: #{@gem_dir}"
+          puts '  Use --force to overwrite, or choose a different name/path.'
+          exit 1
+        end
+
+        FileUtils.mkdir_p(@gem_dir)
+        write_files
+        print_success
+      end
+
+      private
+
+      def normalize_names!
+        # Accept "messaging", "belt-messaging", "Belt::Messaging"
+        name = @raw_name.to_s.strip
+        name = name.sub(/\ABelt::/i, '')
+        name = name.gsub('::', '-')
+        name = name.sub(/\Abelt[-_]/i, '')
+        name = name.gsub(/[^a-z0-9_-]/i, '_').downcase.tr('_', '-')
+        name = name.gsub(/-+/, '-').gsub(/\A-|-\z/, '')
+
+        if name.empty?
+          puts "✗ Invalid plugin name: #{@raw_name.inspect}"
+          exit 1
+        end
+
+        @plugin_name = name # messaging
+        @gem_name = "belt-#{name}" # belt-messaging
+        @module_name = name.split('-').map(&:capitalize).join # Messaging
+        @constant_path = "Belt::#{@module_name}" # Belt::Messaging
+        @generator_class = "#{@module_name}Generator"
+        @summary ||= "#{@module_name} plugin for Belt applications"
+        @gem_dir = File.expand_path(File.join(@path, @gem_name))
+      end
+
+      def write_files
+        files.each do |relative, content|
+          full = File.join(@gem_dir, relative)
+          FileUtils.mkdir_p(File.dirname(full))
+          File.write(full, content)
+          puts "  create  #{File.join(@gem_name, relative)}"
+        end
+      end
+
+      def files
+        gen = "lib/belt/generators/#{@plugin_name.tr('-', '_')}_generator.rb"
+        {
+          "#{@gem_name}.gemspec" => render('gemspec.erb'),
+          'Gemfile' => render('Gemfile.erb'),
+          'Rakefile' => render('Rakefile.erb'),
+          'README.md' => render('README.md.erb'),
+          'AGENTS.md' => render('AGENTS.md.erb'),
+          'CHANGELOG.md' => render('CHANGELOG.md.erb'),
+          'LICENSE' => render('LICENSE.erb'),
+          '.gitignore' => render('gitignore.erb'),
+          '.rspec' => render('rspec.erb'),
+          "lib/#{@gem_name}.rb" => render('lib/entry.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}.rb" => render('lib/belt/module.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/version.rb" => render('lib/belt/module/version.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/configuration.rb" => render('lib/belt/module/configuration.rb.erb'),
+          gen => render('lib/belt/generators/generator.rb.erb'),
+          "lib/belt/#{@plugin_name.tr('-', '_')}/templates/.gitkeep" => '',
+          'spec/spec_helper.rb' => render('spec/spec_helper.rb.erb'),
+          "spec/belt/#{@plugin_name.tr('-', '_')}/configuration_spec.rb" => render('spec/configuration_spec.rb.erb')
+        }
+      end
+
+      def render(template_name)
+        path = File.join(TEMPLATE_DIR, template_name)
+        raise "Missing plugin template: #{path}" unless File.exist?(path)
+
+        erb = ERB.new(File.read(path), trim_mode: '-')
+        # Expose locals used in templates
+        gem_name = @gem_name
+        plugin_name = @plugin_name
+        module_name = @module_name
+        constant_path = @constant_path
+        generator_class = @generator_class
+        summary = @summary
+        underscored = @plugin_name.tr('-', '_')
+        erb.result(binding)
+      end
+
+      def print_success
+        puts ''
+        puts "✓ Created plugin gem #{@gem_name}"
+        puts ''
+        puts 'Next steps:'
+        puts "  1. cd #{@gem_dir}"
+        puts '  2. bundle install'
+        puts '  3. Implement your library under lib/belt/'
+        puts "  4. Flesh out lib/belt/generators/#{@plugin_name.tr('-', '_')}_generator.rb"
+        puts '     (templates go in lib/belt/<name>/templates/)'
+        puts '  5. In a Belt app Gemfile:'
+        puts "       gem \"#{@gem_name}\", path: \"#{@gem_dir}\""
+        puts '  6. bundle install && belt generate --help'
+        puts "     → should list \"#{@plugin_name}\" under Gem Generators"
+        puts "  7. belt generate #{@plugin_name}"
+        puts ''
+        puts 'Reference implementations: belt-messaging, belt-pay'
+      end
+    end
+  end
+end

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

@@ -8,14 +8,14 @@ module Belt
         private
 
         def load_schema_models(routes_file)
-          schema_file = resolve_schema_file(routes_file)
+          schema_file = resolve_contracts_file(routes_file)
           return [] unless schema_file && File.exist?(schema_file)
 
           Belt.instance_variable_set(:@application, nil)
           begin
             eval(File.read(schema_file), binding, schema_file) # rubocop:disable Security/Eval
           rescue StandardError => e
-            warn "Warning: Failed to load schema file #{schema_file}: #{e.message}"
+            warn "Warning: Failed to load contracts file #{schema_file}: #{e.message}"
             return []
           end
 
@@ -23,15 +23,25 @@ module Belt
           build_models_from_schema(schema)
         end
 
-        def resolve_schema_file(routes_file)
+        def resolve_contracts_file(routes_file)
           schema_file = @options[:schema_file]
           unless schema_file
             routes_dir = File.dirname(File.expand_path(routes_file))
-            schema_file = File.join(routes_dir, 'schema.tf.rb')
+            # Check new convention first, then legacy names
+            candidates = [
+              File.join(routes_dir, 'contracts.rb'),
+              File.join(routes_dir, 'contracts.tf.rb'),
+              File.join(routes_dir, 'schema.tf.rb')
+            ]
+            schema_file = candidates.find { |f| File.exist?(f) }
+
             # Fall back to infrastructure/ if not found in same directory as routes
-            unless File.exist?(schema_file)
-              alt = 'infrastructure/schema.tf.rb'
-              schema_file = alt if File.exist?(alt)
+            unless schema_file
+              legacy_candidates = [
+                'infrastructure/contracts.rb',
+                'infrastructure/schema.tf.rb'
+              ]
+              schema_file = legacy_candidates.find { |f| File.exist?(f) }
             end
           end
           schema_file

data/lib/belt/cli/routes_command.rb

@@ -27,7 +27,7 @@ module Belt
         routes_file = find_routes_file
         unless routes_file
           abort 'Error: No routes file found. ' \
-                'Expected config/routes.tf.rb (or infrastructure/routes.tf.rb)'
+                'Expected config/routes.rb (or config/routes.tf.rb, infrastructure/routes.tf.rb)'
         end
 
         dsl = load_routes(routes_file)
@@ -71,7 +71,7 @@ module Belt
             @options[:output_dir] = dir
           end
 
-          opts.on('--schema FILE', 'Path to schema.tf.rb for model definitions') do |file|
+          opts.on('--schema FILE', 'Path to contracts.rb for model definitions') do |file|
             @options[:schema_file] = file
           end
 
@@ -87,7 +87,11 @@ module Belt
       end
 
       def find_routes_file
-        candidates = ['config/routes.tf.rb', 'infrastructure/routes.tf.rb']
+        candidates = [
+          'config/routes.rb',
+          'config/routes.tf.rb',
+          'infrastructure/routes.tf.rb'
+        ]
         candidates.find { |f| File.exist?(f) }
       end
 

data/lib/belt/cli/setup_command.rb

@@ -32,7 +32,7 @@ module Belt
           puts 'Usage: belt setup <state|tables|frontend> [options]'
           puts "\nSubcommands:"
           puts '  state     Set up S3 bucket for Terraform state'
-          puts '  tables    Generate DynamoDB table definitions from schema.tf.rb'
+          puts '  tables    Generate DynamoDB table definitions from contracts.rb'
           puts '  frontend  Generate S3 + CloudFront infrastructure for frontend hosting'
           exit 1
         end

data/lib/belt/cli/views_command.rb

@@ -25,14 +25,19 @@ module Belt
           { name: n, type: t || 'string' }
         end
 
-        # If no fields provided, try to read from schema.tf.rb
+        # If no fields provided, try to read from contracts.rb
         fields = read_schema_fields(name) if fields.empty?
 
         new(name, fields).generate
       end
 
       def self.read_schema_fields(name)
-        schema_file = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb'].find { |f| File.exist?(f) }
+        schema_file = [
+          'config/contracts.rb',
+          'config/contracts.tf.rb',
+          'config/schema.tf.rb',
+          'infrastructure/schema.tf.rb'
+        ].find { |f| File.exist?(f) }
         return [] unless schema_file
 
         content = File.read(schema_file)