belt 0.1.4 → 0.1.6

data/lib/belt/cli/environment_command.rb

@@ -26,9 +26,10 @@ module Belt
         new(env_name).generate
       end
 
-      def initialize(env_name)
+      def initialize(env_name, quiet: false)
         @env_name = env_name.downcase.gsub(/[^a-z0-9_-]/, '')
         @app_name = detect_app_name
+        @quiet = quiet
       end
 
       def generate
@@ -49,11 +50,14 @@ module Belt
         end
 
         puts "\n✓ Environment '#{@env_name}' created!"
-        puts "\nNext steps:"
-        puts "  cd #{dest_dir}"
-        puts '  terraform init'
-        puts '  terraform plan'
-        puts '  terraform apply'
+
+        unless @quiet
+          puts "\nNext steps:"
+          puts "  cd #{dest_dir}"
+          puts '  terraform init'
+          puts '  terraform plan'
+          puts '  terraform apply'
+        end
       end
 
       private
@@ -63,7 +67,8 @@ module Belt
           'main.tf.erb' => 'main.tf',
           'backend.tf.erb' => 'backend.tf',
           'variables.tf.erb' => 'variables.tf',
-          'terraform.tfvars.erb' => 'terraform.tfvars'
+          'terraform.tfvars.erb' => 'terraform.tfvars',
+          'outputs.tf.erb' => 'outputs.tf'
         }
       end
 

data/lib/belt/cli/generate_command.rb

@@ -15,19 +15,79 @@ module Belt
 
       include AppDetection
 
+      FIELD_TYPES = %w[string text integer float boolean date datetime].freeze
+
+      GENERATOR_HELP = {
+        'resource' => {
+          description: 'Generate a model, controller, routes, and schema for a REST resource.',
+          usage: 'belt generate resource <name> [field:type ...] [options]',
+          options: [
+            ['--skip-views', 'Skip generating frontend view pages']
+          ],
+          examples: [
+            ['belt g resource post title:string body:text', 'Post with title and body fields'],
+            ['belt g resource comment author:string body:text status:string', 'Comment with multiple fields'],
+            ['belt g resource task --skip-views', 'Task resource without frontend pages']
+          ],
+          notes: <<~NOTES
+            Creates:
+              lambda/models/<name>.rb                            Model with validations and fields
+              lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
+              infrastructure/routes.tf.rb                        Route entry added
+              infrastructure/schema.tf.rb                        DynamoDB table schema added
+              lambda/lib/routes/<app>_routes.rb                  Route manifest updated
+          NOTES
+        },
+        'model' => {
+          description: 'Generate an ActiveItem model with validations and DynamoDB field definitions.',
+          usage: 'belt generate model <name> [field:type ...]',
+          options: [],
+          examples: [
+            ['belt g model user email:string name:string', 'User model with email and name'],
+            ['belt g model event title:string starts_at:datetime', 'Event model with datetime field']
+          ],
+          notes: <<~NOTES
+            Creates:
+              lambda/models/<name>.rb    Model class inheriting from ActiveItem::Base
+          NOTES
+        },
+        'controller' => {
+          description: 'Generate a controller with standard REST actions.',
+          usage: 'belt generate controller <name>',
+          options: [],
+          examples: [
+            ['belt g controller posts', 'Posts controller with CRUD actions'],
+            ['belt g controller admin/users', 'Namespaced controller']
+          ],
+          notes: <<~NOTES
+            Creates:
+              lambda/controllers/<app>/<name>_controller.rb    Controller class
+          NOTES
+        }
+      }.freeze
+
       def self.run(args)
         generator = args.shift
 
-        if generator.nil? || !GENERATORS.include?(generator)
-          puts "Usage: belt generate <#{GENERATORS.join('|')}> <name> [field:type ...]"
-          puts "\nExamples:"
-          puts '  belt generate resource post title:string content:text status:string'
-          puts '  belt generate model comment body:text author:string'
-          puts '  belt generate controller comments'
-          puts '  belt generate environment dev01'
+        # Top-level help: belt generate --help or belt generate (no args)
+        if generator.nil? || generator =~ /\A-/
+          print_generate_help
+          exit 0
+        end
+
+        unless GENERATORS.include?(generator)
+          puts "Unknown generator: '#{generator}'"
+          puts "Available generators: #{GENERATORS.join(', ')}"
+          puts "\nRun 'belt generate --help' for usage information."
           exit 1
         end
 
+        # Per-generator help: belt g resource --help
+        if args.include?('--help') || args.include?('-h')
+          print_generator_help(generator)
+          exit 0
+        end
+
         return Belt::CLI::EnvironmentCommand.run(args) if generator == 'environment'
 
         return Belt::CLI::FrontendCommand.run(args) if generator == 'frontend'
@@ -36,10 +96,12 @@ module Belt
 
         name = args.shift
         if name.nil? || name.empty?
-          puts "Usage: belt generate #{generator} <name> [field:type ...]"
-          exit 1
+          print_generator_help(generator)
+          exit 0
         end
 
+        validate_resource_name!(name, generator)
+
         skip_views = args.delete('--skip-views')
         fields = args.map { |arg| parse_field(arg) }
         new(generator, name, fields, skip_views: skip_views).generate
@@ -50,12 +112,105 @@ module Belt
         { name: name, type: type || 'string' }
       end
 
+      RESERVED_NAMES = %w[
+        help new edit create update destroy index show delete remove
+        application base controller model resource generate
+        belt setup environment frontend views routes
+      ].freeze
+
+      def self.validate_resource_name!(name, generator)
+        errors = []
+
+        errors << 'must start with a letter' unless name.match?(/\A[a-zA-Z]/)
+        errors << 'must be at least 2 characters' if name.length < 2
+        errors << 'must only contain letters, numbers, and underscores' unless name.match?(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
+        errors << 'must not start or end with an underscore' if name.match?(/\A_|_\z/)
+        errors << 'must not contain consecutive underscores' if name.include?('__')
+        errors << "is a reserved name" if RESERVED_NAMES.include?(name.downcase.chomp('s'))
+        errors << "is a reserved name" if RESERVED_NAMES.include?(name.downcase)
+
+        return if errors.empty?
+
+        puts "\n✗ Invalid #{generator} name '#{name}':"
+        errors.uniq.each { |e| puts "  - #{e}" }
+        puts "\nName must start with a letter, be at least 2 characters, and contain only letters, numbers, and single underscores."
+        exit 1
+      end
+
+      def self.print_generate_help
+        puts <<~HELP
+          Usage: belt generate <generator> <name> [field:type ...] [options]
+                 belt g <generator> <name> [field:type ...] [options]
+
+          Generators:
+            resource      Generate model, controller, routes, and schema (full REST resource)
+            model         Generate an ActiveItem model
+            controller    Generate a controller
+            environment   Create a new deployment environment
+            frontend      Scaffold a frontend app (react, vue, svelte)
+            views         Generate React pages for a resource
+
+          Field Types:
+            #{FIELD_TYPES.join(', ')}
+
+          Examples:
+            belt g resource post title:string body:text status:string
+            belt g model user email:string name:string
+            belt g controller comments
+            belt g environment staging
+            belt g frontend react
+            belt g views post title:string body:text
+
+          Run 'belt generate <generator> --help' for detailed help on a specific generator.
+        HELP
+      end
+
+      def self.print_generator_help(generator)
+        info = GENERATOR_HELP[generator]
+
+        unless info
+          puts "Usage: belt generate #{generator} <name>"
+          puts "\nRun 'belt generate #{generator} --help' is not yet documented."
+          puts "Try 'belt generate --help' for the full list of generators."
+          return
+        end
+
+        puts info[:description]
+        puts
+        puts "Usage: #{info[:usage]}"
+
+        if info[:options].any?
+          puts "\nOptions:"
+          info[:options].each do |flag, desc|
+            puts "  %-20s %s" % [flag, desc]
+          end
+        end
+
+        puts "\nField Types:"
+        puts "  #{FIELD_TYPES.join(', ')}"
+
+        puts "\nExamples:"
+        info[:examples].each do |cmd, desc|
+          puts "  #{cmd}"
+          puts "    #{desc}" if desc
+        end
+
+        puts "\n#{info[:notes]}" if info[:notes]
+
+        puts "Naming Rules:"
+        puts "  - Must start with a letter"
+        puts "  - At least 2 characters"
+        puts "  - Letters, numbers, and single underscores only"
+        puts "  - No leading/trailing/consecutive underscores"
+        puts "  - Cannot use reserved names (help, new, create, destroy, etc.)"
+      end
+
       def initialize(generator, name, fields, skip_views: false)
         @generator = generator
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
         @skip_views = skip_views
-        @app_name = detect_app_name
+        @app_name = detect_namespace
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @resource_name = @name.end_with?('s') ? @name : "#{@name}s"
         @singular_name = @name.end_with?('s') ? @name.chomp('s') : @name

data/lib/belt/cli/new_command.rb

@@ -2,40 +2,76 @@
 
 require 'fileutils'
 require 'erb'
+require 'json'
+require 'open3'
+require_relative 'setup_command'
 
 module Belt
   module CLI
     class NewCommand
       TEMPLATE_DIR = File.expand_path('../../templates/new_app', __dir__)
+      DEFAULT_ENVIRONMENTS = %w[dev prod].freeze
 
       def self.run(args)
         app_name = nil
         frontend = nil
+        bucket = nil
+        environments = nil
 
-        args.each do |arg|
-          if arg.start_with?('--frontend')
-            frontend = if arg.include?('=')
-                         arg.split('=', 2).last
-                       else
-                         args[args.index(arg) + 1]
-                       end
-          elsif !arg.start_with?('-')
-            app_name ||= arg
+        i = 0
+        while i < args.length
+          arg = args[i]
+          case arg
+          when '--frontend'
+            if arg.include?('=')
+              frontend = arg.split('=', 2).last
+            else
+              i += 1
+              frontend = args[i]
+            end
+          when /^--frontend=/
+            frontend = arg.split('=', 2).last
+          when '--bucket', '--state-bucket'
+            i += 1
+            bucket = args[i]
+          when /^--bucket=/
+            bucket = arg.split('=', 2).last
+          when /^--state-bucket=/
+            bucket = arg.split('=', 2).last
+          when '--environments'
+            i += 1
+            environments = args[i]
+          when /^--environments=/
+            environments = arg.split('=', 2).last
+          else
+            app_name ||= arg unless arg.start_with?('-')
           end
+          i += 1
         end
 
         if app_name.nil? || app_name.empty?
-          puts 'Usage: belt new <app_name> [--frontend react|vue|svelte]'
+          puts 'Usage: belt new <app_name> [options]'
+          puts ''
+          puts 'Options:'
+          puts '  --frontend react|vue|svelte    Set up frontend framework'
+          puts '  --bucket BUCKET_NAME           S3 bucket for Terraform state'
+          puts '  --state-bucket BUCKET_NAME     Alias for --bucket'
+          puts '  --environments dev,prod        Comma-separated environments (default: dev,prod)'
+          puts '                                 Use "none" to skip environment setup'
           exit 1
         end
 
-        new(app_name, frontend: frontend).generate
+        new(app_name, frontend: frontend, bucket: bucket, environments: environments).generate
       end
 
-      def initialize(app_name, frontend: nil)
+      def initialize(app_name, frontend: nil, bucket: nil, environments: nil)
         @app_name = app_name.gsub(/[^a-z0-9_-]/i, '_').downcase
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @frontend = frontend
+        @bucket = bucket
+        @environments = parse_environments(environments)
+        @resolved_bucket = nil
+        @state_setup_succeeded = false
       end
 
       def generate
@@ -47,19 +83,23 @@ module Belt
         puts "Creating new Belt application: #{@app_name}"
         create_structure
         generate_frontend if @frontend
+        generate_environments
         init_git
+        run_bundle_install
+        setup_state
         puts "\n✓ #{@app_name} created successfully!"
-        puts "\nNext steps:"
-        puts "  cd #{@app_name}"
-        puts '  bundle install'
-        puts '  cd frontend && npm install && npm run dev' if @frontend
-        puts '  # Define your models in infrastructure/schema.tf.rb'
-        puts '  # Define your routes in infrastructure/routes.tf.rb'
-        puts "  # Add controllers in lambda/controllers/#{@app_name}/"
+        print_next_steps
       end
 
       private
 
+      def parse_environments(env_string)
+        return DEFAULT_ENVIRONMENTS if env_string.nil? || env_string.empty?
+        return [] if env_string.downcase == 'none'
+
+        env_string.split(',').map(&:strip).reject(&:empty?)
+      end
+
       def create_structure
         directories.each { |dir| create_dir(dir) }
         files.each { |src, dest| create_file(src, dest) }
@@ -67,7 +107,7 @@ module Belt
 
       def directories
         %W[
-          #{@app_name}/lambda/controllers/#{@app_name}
+          #{@app_name}/lambda/controllers/api
           #{@app_name}/lambda/models
           #{@app_name}/lambda/models/concerns
           #{@app_name}/lambda/lib/routes
@@ -81,13 +121,13 @@ module Belt
         {
           'Gemfile.erb' => "#{@app_name}/Gemfile",
           'Rakefile.erb' => "#{@app_name}/Rakefile",
-          'lambda/api.rb.erb' => "#{@app_name}/lambda/#{@app_name}.rb",
+          'lambda/api.rb.erb' => "#{@app_name}/lambda/api.rb",
           'lambda/config/environment.rb.erb' => "#{@app_name}/lambda/config/environment.rb",
           'lambda/models/application_record.rb.erb' => "#{@app_name}/lambda/models/application_record.rb",
           'lambda/models/concerns/timestampable.rb.erb' => "#{@app_name}/lambda/models/concerns/timestampable.rb",
           'lambda/controllers/application_controller.rb.erb' =>
-            "#{@app_name}/lambda/controllers/#{@app_name}/application_controller.rb",
-          'lambda/lib/routes/routes.rb.erb' => "#{@app_name}/lambda/lib/routes/#{@app_name}_routes.rb",
+            "#{@app_name}/lambda/controllers/api/application_controller.rb",
+          'lambda/lib/routes/routes.rb.erb' => "#{@app_name}/lambda/lib/routes/api_routes.rb",
           'infrastructure/routes.tf.rb.erb' => "#{@app_name}/infrastructure/routes.tf.rb",
           'infrastructure/schema.tf.rb.erb' => "#{@app_name}/infrastructure/schema.tf.rb",
           'README.md.erb' => "#{@app_name}/README.md",
@@ -96,6 +136,84 @@ module Belt
         }
       end
 
+      def generate_environments
+        return if @environments.empty?
+
+        Dir.chdir(@app_name) do
+          @environments.each do |env_name|
+            Belt::CLI::EnvironmentCommand.new(env_name, quiet: true).generate
+          end
+        end
+      end
+
+      def setup_state
+        return if @environments.empty?
+
+        Dir.chdir(@app_name) do
+          # Resolve bucket name — include account ID + region if AWS credentials are available
+          if @bucket
+            @resolved_bucket = @bucket
+          elsif aws_configured?
+            region = detect_region
+            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state-#{@aws_account_id}-#{region}")
+          else
+            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state")
+          end
+
+          # Update backend.tf files with the resolved bucket name
+          @environments.each do |env_name|
+            backend_file = "infrastructure/#{env_name}/backend.tf"
+            next unless File.exist?(backend_file)
+
+            content = File.read(backend_file)
+            updated = content.gsub(/bucket\s*=\s*"[^"]+"/, "bucket  = \"#{@resolved_bucket}\"")
+            File.write(backend_file, updated) if updated != content
+          end
+
+          # Attempt to actually create the bucket if credentials are available
+          if @aws_account_id
+            puts "\n  Setting up Terraform state bucket..."
+            begin
+              Belt::CLI::SetupCommand.new(["--bucket", @resolved_bucket]).run_state_setup
+              @state_setup_succeeded = true
+            rescue SystemExit
+              puts '  ⚠ State bucket setup encountered an issue — run `belt setup state` to retry.'
+              @state_setup_succeeded = false
+            end
+          else
+            puts "\n  State bucket: #{@resolved_bucket}"
+            if @aws_error&.include?('ForbiddenException') || @aws_error&.include?('AccessDenied')
+              puts "  ⚠ AWS credentials found but access denied — check your profile/role configuration."
+              puts "    #{@aws_error}" if @aws_error
+            else
+              puts '  ⚠ AWS credentials not detected — skipping state bucket creation.'
+            end
+            puts '  Run `belt setup state` after configuring credentials (aws sso login / AWS_PROFILE).'
+            @state_setup_succeeded = false
+          end
+        end
+      end
+
+      def detect_region
+        Dir.glob('infrastructure/*/backend.tf').each do |f|
+          match = File.read(f).match(/region\s*=\s*"([^"]+)"/)
+          return match[1] if match
+        end
+        'us-east-1'
+      end
+
+      def aws_configured?
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        if status.success?
+          data = JSON.parse(output) rescue {}
+          @aws_account_id = data['Account']
+          true
+        else
+          @aws_error = output.strip
+          false
+        end
+      end
+
       def create_dir(dir)
         FileUtils.mkdir_p(dir)
         puts "  create  #{dir}/"
@@ -111,17 +229,42 @@ module Belt
       def init_git
         Dir.chdir(@app_name) do
           system('git', 'init', '--quiet')
-          system('git', 'add', '.')
-          system('git', 'commit', '-m', 'Initial commit', '--quiet')
         end
         puts "  init    #{@app_name}/.git/"
       end
 
+      def run_bundle_install
+        Dir.chdir(@app_name) do
+          puts "\n  Running bundle install..."
+          success = system('bundle', 'install', '--quiet')
+          if success
+            puts '  ✓ Bundle installed'
+          else
+            puts '  ⚠ bundle install failed — run it manually after resolving issues.'
+          end
+        end
+      end
+
       def generate_frontend
         Dir.chdir(@app_name) do
           Belt::CLI::FrontendCommand.new(@frontend).generate
         end
       end
+
+      def print_next_steps
+        puts "\nNext steps:"
+        puts "  cd #{@app_name}"
+        unless @state_setup_succeeded
+          puts '  # Configure AWS credentials (aws sso login / AWS_PROFILE)'
+          puts '  belt setup state              # Create the S3 state bucket'
+        end
+        puts '  belt deploy                   # Deploy to AWS'
+        puts '  belt server                   # Start local frontend server' if @frontend
+      end
+
+      def s3_safe_name(name)
+        name.to_s.downcase.tr('_', '-')
+      end
     end
   end
 end