belt 0.0.7 → 0.1.0

data/lib/belt/cli/generate_command.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require_relative 'app_detection'
+require_relative 'environment_command'
+require_relative 'frontend_command'
+require_relative 'views_command'
+
+module Belt
+  module CLI
+    class GenerateCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/generate', __dir__)
+      GENERATORS = %w[resource model controller environment frontend views].freeze
+
+      include AppDetection
+
+      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'
+          exit 1
+        end
+
+        return Belt::CLI::EnvironmentCommand.run(args) if generator == 'environment'
+
+        return Belt::CLI::FrontendCommand.run(args) if generator == 'frontend'
+
+        return Belt::CLI::ViewsCommand.run(args) if generator == 'views'
+
+        name = args.shift
+        if name.nil? || name.empty?
+          puts "Usage: belt generate #{generator} <name> [field:type ...]"
+          exit 1
+        end
+
+        skip_views = args.delete('--skip-views')
+        fields = args.map { |arg| parse_field(arg) }
+        new(generator, name, fields, skip_views: skip_views).generate
+      end
+
+      def self.parse_field(arg)
+        name, type = arg.split(':', 2)
+        { name: name, type: type || 'string' }
+      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
+        @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
+        @class_name = @singular_name.split('_').map(&:capitalize).join
+      end
+
+      def generate
+        case @generator
+        when 'resource'  then generate_resource
+        when 'model'     then generate_model
+        when 'controller' then generate_controller
+        end
+      end
+
+      private
+
+      def generate_resource
+        generate_model
+        generate_controller
+        inject_routes
+        inject_schema
+        generate_views_if_frontend
+        puts "\n✓ Resource '#{@singular_name}' generated!"
+        puts "\nFiles created/updated:"
+        puts "  lambda/models/#{@singular_name}.rb"
+        puts "  lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
+        puts '  infrastructure/routes.tf.rb (updated)'
+        puts '  infrastructure/schema.tf.rb (updated)'
+        puts "  lambda/lib/routes/#{@app_name}_routes.rb (updated)"
+        puts "  frontend/src/pages/#{@resource_name}/ (views)" if Dir.exist?('frontend/src')
+      end
+
+      def generate_model
+        dest = "lambda/models/#{@singular_name}.rb"
+        write_template('model.rb.erb', dest)
+        puts "  create  #{dest}"
+      end
+
+      def generate_controller
+        dest = "lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
+        write_template('controller.rb.erb', dest)
+        puts "  create  #{dest}"
+      end
+
+      def inject_routes
+        routes_file = 'infrastructure/routes.tf.rb'
+        return unless File.exist?(routes_file)
+
+        content = File.read(routes_file)
+        tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
+
+        # Insert before the closing `end` of the namespace block
+        if content.include?('# resources :posts')
+          content.sub!('# resources :posts', "resources :#{@resource_name}#{tables_arg}")
+        elsif content.match?(/namespace :\w+[^\n]*do\n(\s+#[^\n]*\n)*\s+end/)
+          content.sub!(/^(\s+)(end\s*\z)/m, "\\1  resources :#{@resource_name}#{tables_arg}\n\\1\\2")
+        else
+          content.sub!(/^(\s*end\s*\z)/m, "    resources :#{@resource_name}#{tables_arg}\n\\1")
+        end
+
+        File.write(routes_file, content)
+        puts "  update  #{routes_file}"
+
+        # Also update route manifest
+        inject_route_manifest
+      end
+
+      def inject_route_manifest
+        manifest_file = "lambda/lib/routes/#{@app_name}_routes.rb"
+        return unless File.exist?(manifest_file)
+
+        id_param = "#{@singular_name}_id"
+
+        new_routes = [
+          "{ verb: 'GET', path: '/#{@resource_name}', controller: '#{@resource_name}', action: 'index' }",
+          "{ verb: 'POST', path: '/#{@resource_name}', controller: '#{@resource_name}', action: 'create' }",
+          "{ verb: 'GET', path: '/#{@resource_name}/{#{id_param}}', controller: '#{@resource_name}', action: 'show' }",
+          "{ verb: 'PUT', path: '/#{@resource_name}/{#{id_param}}', " \
+          "controller: '#{@resource_name}', action: 'update' }",
+          "{ verb: 'DELETE', path: '/#{@resource_name}/{#{id_param}}', " \
+          "controller: '#{@resource_name}', action: 'destroy' }"
+        ]
+
+        existing_content = File.read(manifest_file)
+        constant = @app_name.upcase
+
+        # Extract existing route entries (preserve routes from other resources)
+        existing_routes = existing_content.scan(/\{ verb: .+? \}/)
+
+        # Merge: replace routes for this resource, keep everything else
+        other_routes = existing_routes.reject { |r| r.include?("controller: '#{@resource_name}'") }
+        all_routes = other_routes + new_routes
+        route_lines = all_routes.map { |r| "    #{r}" }.join(",\n")
+
+        content = <<~RUBY
+          # frozen_string_literal: true
+
+          module Routes
+            #{constant} = [
+          #{route_lines}
+            ].freeze
+          end
+        RUBY
+
+        File.write(manifest_file, content)
+        puts "  update  #{manifest_file}"
+      end
+
+      def inject_schema
+        schema_file = 'infrastructure/schema.tf.rb'
+        return unless File.exist?(schema_file)
+
+        content = File.read(schema_file)
+
+        field_lines = @fields.map { |f| "    field :#{f[:name]}, type: :#{f[:type]}" }
+        field_lines << '    field :created_at, type: :string'
+        field_lines << '    field :updated_at, type: :string'
+
+        schema_block = "  model :#{@singular_name} do\n#{field_lines.join("\n")}\n  end\n"
+
+        # Replace commented-out block or insert before final end
+        if content.match?(/^\s*#\s*model :/)
+          content.gsub!(/^\s*#[^\n]*\n/, '')
+          content.sub!(/^(end\s*\z)/m, "#{schema_block}\\1")
+        else
+          content.sub!(/^(end\s*\z)/m, "\n#{schema_block}\\1")
+        end
+
+        File.write(schema_file, content)
+        puts "  update  #{schema_file}"
+      end
+
+      def write_template(template_name, dest_path)
+        template_path = File.join(TEMPLATE_DIR, template_name)
+        FileUtils.mkdir_p(File.dirname(dest_path))
+        content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+        File.write(dest_path, content)
+      end
+
+      def generate_views_if_frontend
+        return unless Dir.exist?('frontend/src')
+        return if @skip_views
+
+        Belt::CLI::ViewsCommand.new(@name, @fields).generate
+      end
+    end
+  end
+end

data/lib/belt/cli/new_command.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+
+module Belt
+  module CLI
+    class NewCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/new_app', __dir__)
+
+      def self.run(args)
+        app_name = nil
+        frontend = 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
+          end
+        end
+
+        if app_name.nil? || app_name.empty?
+          puts 'Usage: belt new <app_name> [--frontend react|vue|svelte]'
+          exit 1
+        end
+
+        new(app_name, frontend: frontend).generate
+      end
+
+      def initialize(app_name, frontend: nil)
+        @app_name = app_name.gsub(/[^a-z0-9_-]/i, '_').downcase
+        @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
+        @frontend = frontend
+      end
+
+      def generate
+        if Dir.exist?(@app_name)
+          puts "Directory '#{@app_name}' already exists."
+          exit 1
+        end
+
+        puts "Creating new Belt application: #{@app_name}"
+        create_structure
+        generate_frontend if @frontend
+        init_git
+        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}/"
+      end
+
+      private
+
+      def create_structure
+        directories.each { |dir| create_dir(dir) }
+        files.each { |src, dest| create_file(src, dest) }
+      end
+
+      def directories
+        %W[
+          #{@app_name}/lambda/controllers/#{@app_name}
+          #{@app_name}/lambda/models
+          #{@app_name}/lambda/models/concerns
+          #{@app_name}/lambda/lib/routes
+          #{@app_name}/lambda/spec
+          #{@app_name}/infrastructure
+        ]
+      end
+
+      def files
+        {
+          'Gemfile.erb' => "#{@app_name}/Gemfile",
+          'lambda/Gemfile.erb' => "#{@app_name}/lambda/Gemfile",
+          'lambda/api.rb.erb' => "#{@app_name}/lambda/#{@app_name}.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",
+          '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",
+          'AGENTS.md.erb' => "#{@app_name}/AGENTS.md",
+          'gitignore.erb' => "#{@app_name}/.gitignore"
+        }
+      end
+
+      def create_dir(dir)
+        FileUtils.mkdir_p(dir)
+        puts "  create  #{dir}/"
+      end
+
+      def create_file(template_name, dest_path)
+        template_path = File.join(TEMPLATE_DIR, template_name)
+        content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+        File.write(dest_path, content)
+        puts "  create  #{dest_path}"
+      end
+
+      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 generate_frontend
+        Dir.chdir(@app_name) do
+          Belt::CLI::FrontendCommand.new(@frontend).generate
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/setup_command.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+require 'open3'
+require_relative 'app_detection'
+require_relative 'bucket_security'
+require_relative 'tables_command'
+require_relative 'frontend_setup_command'
+
+module Belt
+  module CLI
+    class SetupCommand
+      SUBCOMMANDS = %w[state tables frontend].freeze
+
+      SECURITY_CHECKS = %i[versioning encryption public_access_block tls_policy].freeze
+
+      include AppDetection
+      include BucketSecurity
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'state'
+          new(args).run_state_setup
+        when 'tables'
+          Belt::CLI::TablesCommand.run(args)
+        when 'frontend'
+          Belt::CLI::FrontendSetupCommand.run(args)
+        else
+          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 '  frontend  Generate S3 + CloudFront infrastructure for frontend hosting'
+          exit 1
+        end
+      end
+
+      def initialize(args = [])
+        @app_name = detect_app_name
+        @env_name = nil
+        @custom_bucket = nil
+        @select_mode = false
+
+        parse_args(args)
+
+        @region = detect_region
+        @bucket_name = resolve_bucket_name
+      end
+
+      def run_state_setup
+        unless aws_configured?
+          puts '✗ AWS credentials not configured. Set AWS_PROFILE or configure aws sso login.'
+          exit 1
+        end
+
+        @bucket_name = interactive_bucket_selection if @select_mode
+        setup_or_verify_bucket
+        apply_lifecycle(@bucket_name)
+        puts '  ensure  lifecycle rules (90-day noncurrent expiration)'
+        update_backend_config
+        print_success_message
+      end
+
+      def setup_or_verify_bucket
+        if bucket_exists?(@bucket_name)
+          verify_existing_bucket
+        else
+          create_new_bucket
+        end
+      end
+
+      def verify_existing_bucket
+        puts "Found existing bucket: #{@bucket_name}"
+        audit = audit_bucket_security(@bucket_name)
+        print_security_audit(audit)
+
+        if audit.values.all?
+          puts "\n✓ Bucket '#{@bucket_name}' passes all security checks"
+        else
+          prompt_and_harden(audit)
+        end
+      end
+
+      def prompt_and_harden(audit)
+        puts "\n⚠ Bucket '#{@bucket_name}' has security issues."
+        print "\nApply security hardening? [Y/n] "
+        response = $stdin.gets&.strip&.downcase
+        if response.nil? || response.empty? || response == 'y'
+          harden_bucket(@bucket_name, audit)
+        else
+          puts '✗ Refusing to use insecure bucket. Fix manually or choose a different bucket.'
+          exit 1
+        end
+      end
+
+      def create_new_bucket
+        puts "Creating state bucket: #{@bucket_name} (#{@region})"
+        create_bucket(@bucket_name)
+        puts "  create  s3://#{@bucket_name}"
+        harden_bucket(@bucket_name, {})
+      end
+
+      def print_success_message
+        puts "\n✓ State bucket '#{@bucket_name}' is ready!"
+        if @env_name
+          puts "\n  cd infrastructure/#{@env_name} && terraform init"
+        else
+          puts "\n  cd infrastructure/<env> && terraform init"
+        end
+      end
+
+      private
+
+      def parse_args(args)
+        while (arg = args.shift)
+          case arg
+          when '--bucket'
+            @custom_bucket = args.shift
+            abort '✗ --bucket requires a value' unless @custom_bucket
+          when '--select'
+            @select_mode = true
+          when '--help', '-h'
+            self.class.run([])
+          else
+            @env_name = arg unless arg.start_with?('-')
+          end
+        end
+      end
+
+      def resolve_bucket_name
+        if @custom_bucket
+          @custom_bucket
+        elsif @env_name
+          "#{@app_name}-terraform-state-#{@env_name}"
+        else
+          "#{@app_name}-terraform-state"
+        end
+      end
+
+      # --- Interactive selection ---
+
+      def interactive_bucket_selection
+        puts "Listing S3 buckets in account...\n\n"
+        buckets = list_buckets
+        if buckets.empty?
+          puts 'No buckets found. Creating a new one.'
+          return @bucket_name
+        end
+
+        # Show buckets with index
+        buckets.each_with_index do |b, i|
+          puts "  [#{i + 1}] #{b}"
+        end
+        puts "  [N] Create new bucket (#{@bucket_name})"
+        puts ''
+        print "Select bucket [1-#{buckets.size}] or N for new: "
+        choice = $stdin.gets&.strip
+
+        if choice.nil? || choice.downcase == 'n' || choice.empty?
+          @bucket_name
+        else
+          idx = choice.to_i - 1
+          if idx >= 0 && idx < buckets.size
+            buckets[idx]
+          else
+            puts '✗ Invalid selection'
+            exit 1
+          end
+        end
+      end
+
+      def list_buckets
+        output = safe_capture('aws', 's3api', 'list-buckets', '--query', 'Buckets[].Name', '--output', 'json')
+        return [] unless output
+
+        JSON.parse(output)
+      rescue JSON::ParserError
+        []
+      end
+
+      # --- AWS operations ---
+
+      def aws_configured?
+        system('aws', 'sts', 'get-caller-identity', out: File::NULL, err: File::NULL)
+      end
+
+      def bucket_exists?(bucket)
+        system('aws', 's3api', 'head-bucket', '--bucket', bucket, err: File::NULL)
+      end
+
+      def create_bucket(bucket)
+        args = ['aws', 's3api', 'create-bucket', '--bucket', bucket, '--region', @region]
+        args.push('--create-bucket-configuration', "LocationConstraint=#{@region}") unless @region == 'us-east-1'
+        run!(*args)
+      end
+
+      def apply_lifecycle(bucket)
+        lifecycle = {
+          Rules: [{
+            ID: 'expire-noncurrent-versions',
+            Status: 'Enabled',
+            Filter: {},
+            NoncurrentVersionExpiration: { NoncurrentDays: 90 },
+            AbortIncompleteMultipartUpload: { DaysAfterInitiation: 7 }
+          }]
+        }
+        run!('aws', 's3api', 'put-bucket-lifecycle-configuration', '--bucket', bucket,
+             '--lifecycle-configuration', JSON.generate(lifecycle))
+      end
+
+      def run!(*args)
+        return if system(*args)
+
+        puts "\n✗ Command failed: #{args.shelljoin}"
+        exit 1
+      end
+
+      def safe_capture(*)
+        output, status = Open3.capture2(*, err: File::NULL)
+        status.success? ? output : nil
+      end
+
+      # --- Backend config ---
+
+      def update_backend_config
+        dirs = if @env_name
+                 [File.join('infrastructure', @env_name)]
+               else
+                 Dir.glob('infrastructure/*/').select { |d| File.exist?(File.join(d, 'backend.tf')) }
+               end
+
+        dirs.each do |env_dir|
+          next unless Dir.exist?(env_dir)
+
+          backend_file = File.join(env_dir, 'backend.tf')
+          next unless File.exist?(backend_file)
+
+          content = File.read(backend_file)
+          updated = content.gsub(/bucket\s*=\s*"[^"]+"/, "bucket  = \"#{@bucket_name}\"")
+          if updated != content
+            File.write(backend_file, updated)
+            puts "  update  #{backend_file} → bucket = \"#{@bucket_name}\""
+          end
+        end
+      end
+
+      # --- Detection ---
+
+      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
+    end
+  end
+end