belt 0.0.7 → 0.1.1

data/lib/belt/cli/frontend_deploy_command.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'open3'
+require_relative 'app_detection'
+require_relative 'env_resolver'
+
+module Belt
+  module CLI
+    class FrontendDeployCommand
+      include AppDetection
+
+      def self.run(args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts 'Usage: belt deploy frontend <environment>'
+          puts "\nBuilds the frontend app and deploys to S3 + invalidates CloudFront."
+          puts 'You can also set BELT_ENV to skip the environment argument.'
+          puts "\nExamples:"
+          puts '  belt deploy frontend wups'
+          puts '  belt deploy frontend dev01'
+          puts '  BELT_ENV=wups belt deploy frontend'
+          exit 1
+        end
+
+        new(env).run
+      end
+
+      def initialize(env)
+        @env = env
+        @app_name = detect_app_name
+        @env_dir = "infrastructure/#{@env}"
+      end
+
+      def run
+        validate!
+        build_frontend
+        sync_to_s3
+        invalidate_cloudfront
+        url = fetch_frontend_url
+        puts "\n✅ Frontend deployed to #{@env}!"
+        puts "   #{url}" if url
+      end
+
+      private
+
+      def validate!
+        unless Dir.exist?('frontend')
+          abort 'Error: No frontend/ directory found. Run `belt generate frontend react` first.'
+        end
+        return if File.exist?('frontend/package.json')
+
+        abort 'Error: frontend/package.json not found.'
+      end
+
+      def build_frontend
+        puts '📦 Installing dependencies...'
+        install_cmd = File.exist?('frontend/package-lock.json') ? %w[npm ci] : %w[npm install]
+        run!(*install_cmd, chdir: 'frontend')
+
+        puts '🏗️  Building frontend...'
+        api_url = fetch_api_url
+        env = api_url ? { 'VITE_API_URL' => api_url } : {}
+        run!(env, 'npm', 'run', 'build', chdir: 'frontend')
+      end
+
+      def sync_to_s3
+        bucket = fetch_bucket_name
+        abort "Error: Could not determine S3 bucket. Run `belt apply #{@env}` first." unless bucket
+
+        puts "☁️  Deploying to S3... (#{bucket})"
+
+        # Hashed assets get immutable cache headers
+        run!('aws', 's3', 'sync', 'frontend/dist/', "s3://#{bucket}", '--delete',
+             '--size-only', '--cache-control', 'public, max-age=31536000, immutable',
+             '--exclude', 'index.html')
+
+        # index.html always revalidates
+        run!('aws', 's3', 'cp', 'frontend/dist/index.html', "s3://#{bucket}/index.html",
+             '--cache-control', 'no-cache')
+      end
+
+      def invalidate_cloudfront
+        dist_id = fetch_distribution_id
+        unless dist_id
+          puts '⚠️  No CloudFront distribution found (skipping cache invalidation)'
+          return
+        end
+
+        puts '🔄 Invalidating CloudFront cache...'
+        run!('aws', 'cloudfront', 'create-invalidation', '--distribution-id', dist_id, '--paths', '/*',
+             out: File::NULL)
+        puts '✅ CloudFront cache invalidated'
+      end
+
+      def fetch_api_url
+        output, status = Open3.capture2('terraform', 'output', '-raw', 'api_url', chdir: @env_dir)
+        status.success? && !output.strip.empty? ? output.strip : nil
+      end
+
+      def fetch_bucket_name
+        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_bucket_name', chdir: @env_dir)
+        status.success? && !output.strip.empty? ? output.strip : nil
+      end
+
+      def fetch_distribution_id
+        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_distribution_id', chdir: @env_dir)
+        status.success? && !output.strip.empty? ? output.strip : nil
+      end
+
+      def fetch_frontend_url
+        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_url', chdir: @env_dir)
+        status.success? && !output.strip.empty? ? output.strip : nil
+      end
+
+      def run!(*args, **)
+        env = args.first.is_a?(Hash) ? args.shift : {}
+        return if system(env, *args, **)
+
+        abort "\n✗ Command failed: #{args.shelljoin}"
+      end
+    end
+  end
+end

data/lib/belt/cli/frontend_setup_command.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require_relative 'app_detection'
+require_relative 'env_resolver'
+
+module Belt
+  module CLI
+    class FrontendSetupCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/frontend_infra', __dir__)
+
+      include AppDetection
+
+      def self.run(args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts 'Usage: belt setup frontend <environment>'
+          puts "\nGenerates S3 + CloudFront Terraform for frontend hosting."
+          puts 'You can also set BELT_ENV to skip the environment argument.'
+          puts "\nExamples:"
+          puts '  belt setup frontend wups'
+          puts '  belt setup frontend dev01'
+          puts '  BELT_ENV=wups belt setup frontend'
+          exit 1
+        end
+
+        new(env).run
+      end
+
+      def initialize(env)
+        @env = env
+        @app_name = detect_app_name
+        @env_dir = "infrastructure/#{@env}"
+      end
+
+      def run
+        validate!
+        generate_frontend_tf
+        puts "\n✓ Frontend infrastructure generated for '#{@env}'!"
+        puts "\nRun `belt apply #{@env}` to create the S3 bucket and CloudFront distribution."
+        puts "Then `belt deploy frontend #{@env}` to build and deploy."
+      end
+
+      private
+
+      def validate!
+        return if Dir.exist?(@env_dir)
+
+        abort "Error: Environment '#{@env}' not found at #{@env_dir}/.\n" \
+              "Create it with: belt generate environment #{@env}"
+      end
+
+      def generate_frontend_tf
+        dest = File.join(@env_dir, 'frontend.tf')
+        template_path = File.join(TEMPLATE_DIR, 'frontend.tf.erb')
+        content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+        File.write(dest, content)
+        puts "  create  #{dest}"
+      end
+    end
+  end
+end

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,126 @@
+# 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",
+          'Rakefile.erb' => "#{@app_name}/Rakefile",
+          '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/routes_command/route_inference.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    class RoutesCommand
+      # Extracts route controller/action inference logic from RoutesCommand.
+      module RouteInference
+        private
+
+        def infer_controller(route, gateway)
+          return route.controller.to_s if route.controller
+
+          segments = route.path.split('/').reject(&:empty?)
+          non_param = segments.reject { |s| s.start_with?(':', '{') }
+          return gateway.name if non_param.empty?
+
+          return non_param.map { |s| s.gsub('-', '_') }.join('/') if route.resource? && nested_resource?(segments)
+
+          if route.resource?
+            non_param.first.gsub('-', '_')
+          elsif non_param.length == 1 && segments.length == 1
+            route.lambda.to_s == gateway.name.to_s ? gateway.name.to_s : route.lambda.to_s
+          else
+            non_param.first.gsub('-', '_')
+          end
+        end
+
+        def infer_action(route, _gateway)
+          return route.action.to_s if route.action
+
+          segments = route.path.split('/').reject(&:empty?)
+          verb = route.method
+
+          if route.singular_resource?
+            infer_singular_resource_action(verb)
+          elsif route.plural_resource?
+            infer_plural_resource_action(verb, segments)
+          else
+            infer_plain_action(verb, segments)
+          end
+        end
+
+        def infer_singular_resource_action(verb)
+          case verb
+          when 'GET' then 'show'
+          when 'PUT', 'PATCH' then 'update'
+          when 'DELETE' then 'destroy'
+          when 'POST' then 'create'
+          else 'show'
+          end
+        end
+
+        def infer_plural_resource_action(verb, segments)
+          has_id = segments.any? { |s| s.start_with?(':', '{') }
+          last_is_param = segments.last&.start_with?(':', '{')
+
+          if nested_resource?(segments)
+            child_idx = segments.rindex { |s| !s.start_with?(':', '{') }
+            has_child_id = child_idx && segments[(child_idx + 1)..]&.any? { |s| s.start_with?(':', '{') }
+            restful_action(verb, has_child_id || false)
+          else
+            restful_action(verb, has_id && last_is_param)
+          end
+        end
+
+        def infer_plain_action(verb, segments)
+          non_param = segments.reject { |s| s.start_with?(':', '{') }
+          has_id = segments.any? { |s| s.start_with?(':', '{') }
+          last_is_param = segments.last&.start_with?(':', '{')
+
+          if non_param.length <= 1 && !has_id
+            non_param.first&.gsub('-', '_') || 'index'
+          elsif non_param.length > 1
+            non_param.last.gsub('-', '_')
+          else
+            restful_action(verb, has_id && last_is_param)
+          end
+        end
+
+        def nested_resource?(segments)
+          segments.length >= 3 &&
+            !segments[0].start_with?(':', '{') &&
+            segments[1]&.start_with?(':', '{') &&
+            !segments[2]&.start_with?(':', '{')
+        end
+
+        def restful_action(verb, is_member)
+          case [verb, is_member]
+          when ['GET', false] then 'index'
+          when ['GET', true] then 'show'
+          when ['POST', false] then 'create'
+          when ['PUT', true], ['PATCH', true] then 'update'
+          when ['DELETE', true] then 'destroy'
+          else 'index'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    class RoutesCommand
+      # Extracts schema model loading logic from RoutesCommand.
+      module SchemaLoader
+        private
+
+        def load_schema_models(routes_file)
+          schema_file = resolve_schema_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}"
+            return []
+          end
+
+          schema = Belt.application.schema.to_h
+          build_models_from_schema(schema)
+        end
+
+        def resolve_schema_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')
+          end
+          schema_file
+        end
+
+        def build_models_from_schema(schema)
+          models = []
+
+          (schema[:request_models] || {}).each_value do |model|
+            models << {
+              name: model[:name],
+              kind: 'request',
+              description: "Request model: #{model[:name]}",
+              properties: stringify_properties(model[:properties] || {}),
+              required: (model[:required] || []).map(&:to_s)
+            }
+          end
+
+          (schema[:response_models] || {}).each_value do |model|
+            (model[:contexts] || {}).each do |ctx_name, ctx|
+              models << {
+                name: "#{model[:name]}_#{ctx_name}_response",
+                kind: 'response',
+                description: "Response model: #{model[:name]} (#{ctx_name} context)",
+                properties: stringify_properties(ctx[:properties] || {}),
+                required: []
+              }
+            end
+          end
+
+          models
+        end
+
+        def stringify_properties(properties)
+          properties.each_with_object({}) do |(key, value), hash|
+            hash[key.to_s] = value.transform_keys(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end