belt 0.0.7 → 0.1.1

data/lib/belt/cli/tasks_command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'optparse'
+
+module Belt
+  module CLI
+    class TasksCommand
+      def self.run(args)
+        new(args).run
+      end
+
+      # Check if a given command name looks like a rake task that exists
+      def self.rake_task?(name)
+        return false unless name.include?(':') || name.match?(/\A[a-z_]+\z/)
+        return false unless File.exist?('Rakefile') || File.exist?('rakefile') || File.exist?('Rakefile.rb')
+
+        # Only treat colon-namespaced commands as potential rake tasks to avoid
+        # ambiguity with belt's own commands
+        name.include?(':')
+      end
+
+      # Invoke a specific rake task by name
+      def self.invoke(task_name, args)
+        unless File.exist?('Rakefile') || File.exist?('rakefile') || File.exist?('Rakefile.rb')
+          abort "Error: No Rakefile found. Cannot run task '#{task_name}'."
+        end
+
+        cmd = ['bundle', 'exec', 'rake', task_name] + args
+        exec(*cmd)
+      end
+
+      def initialize(args)
+        @options = {}
+        parse_options(args)
+      end
+
+      def run
+        abort 'Error: No Rakefile found. Add a Rakefile to your project to discover tasks.' unless rakefile_available?
+
+        tasks = load_tasks
+        tasks = apply_grep(tasks) if @options[:grep]
+
+        if tasks.empty?
+          puts 'No rake tasks found.'
+        else
+          output_tasks(tasks)
+        end
+      end
+
+      private
+
+      def parse_options(args)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: belt tasks [options]'
+
+          opts.on('-g', '--grep PATTERN', 'Filter tasks matching pattern') do |pattern|
+            @options[:grep] = pattern
+          end
+
+          opts.on('-a', '--all', 'Show all tasks (including those without descriptions)') do
+            @options[:all] = true
+          end
+
+          opts.on('-h', '--help', 'Show this help') do
+            puts opts
+            exit
+          end
+        end.parse!(args)
+      end
+
+      def rakefile_available?
+        File.exist?('Rakefile') || File.exist?('rakefile') || File.exist?('Rakefile.rb')
+      end
+
+      def load_tasks
+        cmd = @options[:all] ? %w[bundle exec rake -T -A] : %w[bundle exec rake -T]
+        output, status = Open3.capture2(*cmd, err: File::NULL)
+
+        abort 'Error: Failed to load rake tasks. Ensure `bundle install` has been run.' unless status.success?
+
+        parse_task_output(output)
+      end
+
+      def parse_task_output(output)
+        output.lines.filter_map do |line|
+          match = line.match(/^rake\s+(\S+)\s*#\s*(.*)$/)
+          next unless match
+
+          { name: match[1], description: match[2].strip }
+        end
+      end
+
+      def apply_grep(tasks)
+        pattern = Regexp.new(@options[:grep], Regexp::IGNORECASE)
+        tasks.select do |t|
+          t[:name].match?(pattern) || t[:description].match?(pattern)
+        end
+      end
+
+      def output_tasks(tasks)
+        name_w = [tasks.map { |t| t[:name].length }.max, 4].max
+
+        tasks.each do |t|
+          puts "belt #{t[:name].ljust(name_w)}  # #{t[:description]}"
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/terraform_command.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'env_resolver'
+
+module Belt
+  module CLI
+    class TerraformCommand
+      ACTIONS = %w[init plan apply destroy output].freeze
+
+      def self.run(action, args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts "Usage: belt #{action} <environment> [terraform flags...]"
+          puts "\nYou can also set BELT_ENV to skip the environment argument."
+          puts "\nExamples:"
+          puts "  belt #{action} wups"
+          puts "  belt #{action} dev01"
+          puts "  BELT_ENV=wups belt #{action}"
+          puts '  belt plan staging -target=module.lambda'
+          puts "\nAvailable environments:"
+          list_environments.each { |e| puts "  #{e}" }
+          exit 1
+        end
+
+        new(action, env, args).run
+      end
+
+      def self.list_environments
+        infra_dir = find_infrastructure_dir
+        return [] unless infra_dir
+
+        Dir.children(infra_dir)
+           .select { |d| File.directory?(File.join(infra_dir, d)) }
+           .reject { |d| d.start_with?('.') || d == 'modules' }
+           .sort
+      end
+
+      def self.find_infrastructure_dir
+        %w[infrastructure infra].each do |dir|
+          return dir if Dir.exist?(dir)
+        end
+        nil
+      end
+
+      def initialize(action, env, extra_args)
+        @action = action
+        @env = env
+        @extra_args = extra_args
+        @infra_dir = self.class.find_infrastructure_dir
+      end
+
+      def run
+        validate!
+        env_dir = File.join(@infra_dir, @env)
+        args = ['terraform', @action, *@extra_args]
+        puts "belt → #{args.join(' ')}  (in #{env_dir}/)"
+        Dir.chdir(env_dir) { exec(*args) }
+      end
+
+      private
+
+      def validate!
+        unless @infra_dir
+          abort "Error: No infrastructure/ directory found. Run `belt generate environment #{@env}` first."
+        end
+
+        env_dir = File.join(@infra_dir, @env)
+        return if Dir.exist?(env_dir)
+
+        abort "Error: Environment '#{@env}' not found at #{env_dir}/.\n\n" \
+              "Available environments:\n#{self.class.list_environments.map { |e| "  #{e}" }.join("\n")}\n\n" \
+              "Create it with: belt generate environment #{@env}"
+      end
+    end
+  end
+end

data/lib/belt/cli/views_command.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+
+module Belt
+  module CLI
+    class ViewsCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/views', __dir__)
+
+      def self.run(args)
+        name = args.shift
+        if name.nil? || name.empty?
+          puts 'Usage: belt generate views <resource> [field:type ...]'
+          puts "\nGenerates React pages for all REST actions (index, show, new, edit)."
+          puts "\nExamples:"
+          puts '  belt generate views post title:string content:text status:string'
+          puts '  belt generate views comment body:text author:string'
+          exit 1
+        end
+
+        fields = args.map do |arg|
+          n, t = arg.split(':', 2)
+          { name: n, type: t || 'string' }
+        end
+
+        # If no fields provided, try to read from schema.tf.rb
+        fields = read_schema_fields(name) if fields.empty?
+
+        new(name, fields).generate
+      end
+
+      def self.read_schema_fields(name)
+        schema_file = 'infrastructure/schema.tf.rb'
+        return [] unless File.exist?(schema_file)
+
+        content = File.read(schema_file)
+        singular = name.end_with?('s') ? name.chomp('s') : name
+
+        # Extract fields from model block
+        if content =~ /model :#{singular} do\n(.*?)\n\s*end/m
+          ::Regexp.last_match(1).scan(/field :(\w+), type: :(\w+)/).except('created_at', 'updated_at')
+                  .map do |n, t|
+            {
+              name: n, type: t
+            }
+          end
+        else
+          []
+        end
+      end
+
+      def initialize(name, fields)
+        @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
+        @fields = fields
+        @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
+        unless Dir.exist?('frontend/src')
+          puts '✗ No frontend/ directory found. Run `belt generate frontend react` first.'
+          exit 1
+        end
+
+        pages_dir = "frontend/src/pages/#{@resource_name}"
+        FileUtils.mkdir_p(pages_dir)
+
+        write_template('Index.jsx.erb', "#{pages_dir}/#{@class_name}sIndex.jsx")
+        write_template('Show.jsx.erb', "#{pages_dir}/#{@class_name}Show.jsx")
+        write_template('New.jsx.erb', "#{pages_dir}/#{@class_name}New.jsx")
+        write_template('Edit.jsx.erb', "#{pages_dir}/#{@class_name}Edit.jsx")
+        write_template('Form.jsx.erb', "#{pages_dir}/#{@class_name}Form.jsx")
+
+        inject_routes
+
+        puts "\n✓ Views for '#{@singular_name}' generated!"
+        puts "\nFiles created:"
+        puts "  #{pages_dir}/#{@class_name}sIndex.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)'
+      end
+
+      private
+
+      def write_template(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 inject_routes
+        app_jsx = 'frontend/src/App.jsx'
+        return unless File.exist?(app_jsx)
+
+        content = File.read(app_jsx)
+        pages_dir = @resource_name
+
+        import_lines = [
+          "import #{@class_name}sIndex from './pages/#{pages_dir}/#{@class_name}sIndex'",
+          "import #{@class_name}Show from './pages/#{pages_dir}/#{@class_name}Show'",
+          "import #{@class_name}New from './pages/#{pages_dir}/#{@class_name}New'",
+          "import #{@class_name}Edit from './pages/#{pages_dir}/#{@class_name}Edit'"
+        ]
+
+        route_lines = [
+          "        <Route path=\"/#{@resource_name}\" element={<#{@class_name}sIndex />} />",
+          "        <Route path=\"/#{@resource_name}/new\" element={<#{@class_name}New />} />",
+          "        <Route path=\"/#{@resource_name}/:id\" element={<#{@class_name}Show />} />",
+          "        <Route path=\"/#{@resource_name}/:id/edit\" element={<#{@class_name}Edit />} />"
+        ]
+
+        # Add imports after last import line
+        last_import_idx = content.rindex(/^import .+$/)
+        if last_import_idx
+          end_of_line = content.index("\n", last_import_idx)
+          content.insert(end_of_line, "\n#{import_lines.join("\n")}")
+        end
+
+        # Add routes before closing </Routes> (no regex — avoids polynomial backtracking)
+        close_idx = content.index('</Routes>')
+        content.insert(close_idx, "#{route_lines.join("\n")}\n") if close_idx
+
+        File.write(app_jsx, content)
+        puts "  update  #{app_jsx}"
+      end
+    end
+  end
+end

data/lib/belt/cli.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'root'
+require_relative 'cli/env_resolver'
+require_relative 'cli/new_command'
+require_relative 'cli/generate_command'
+require_relative 'cli/frontend_command'
+require_relative 'cli/frontend_setup_command'
+require_relative 'cli/frontend_deploy_command'
+require_relative 'cli/views_command'
+require_relative 'cli/setup_command'
+require_relative 'cli/terraform_command'
+require_relative 'cli/routes_command'
+require_relative 'cli/tasks_command'
+
+module Belt
+  module CLI
+    COMMANDS_DEFINITION = {
+      'new' => Belt::CLI::NewCommand,
+      %w[generate g] => Belt::CLI::GenerateCommand,
+      'routes' => Belt::CLI::RoutesCommand,
+      %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
+      'setup' => Belt::CLI::SetupCommand,
+      'deploy' => lambda { |args|
+        subcommand = args.shift
+        if subcommand == 'frontend'
+          Belt::CLI::FrontendDeployCommand.run(args)
+        else
+          puts 'Usage: belt deploy frontend <environment>'
+          exit 1
+        end
+      },
+      %w[version --version -v] => ->(_args) { puts "Belt #{Belt::VERSION}" }
+    }.freeze
+
+    COMMANDS = COMMANDS_DEFINITION.each_with_object({}) do |(keys, handler), hash|
+      Array(keys).each { |key| hash[key] = handler }
+    end.freeze
+
+    TERRAFORM_ACTIONS = Belt::CLI::TerraformCommand::ACTIONS
+
+    def self.start(args)
+      command = args.shift
+
+      if command.nil?
+        puts usage
+        exit 1
+      end
+
+      # Terraform shorthand: belt init wups, belt plan wups, belt apply wups
+      return Belt::CLI::TerraformCommand.run(command, args) if TERRAFORM_ACTIONS.include?(command)
+
+      handler = COMMANDS[command]
+
+      # If no built-in command matched, try running it as a rake task
+      if handler.nil?
+        return Belt::CLI::TasksCommand.invoke(command, args) if Belt::CLI::TasksCommand.rake_task?(command)
+
+        puts "Unknown command: #{command}\n\n#{usage}"
+        exit 1
+      end
+
+      if handler.is_a?(Proc)
+        handler.call(args)
+      else
+        handler.run(args)
+      end
+    end
+
+    def self.usage
+      <<~USAGE
+        Usage: belt <command> [options]
+
+        Commands:
+          new <app_name> [--frontend react]           Create a new Belt application
+          generate <resource|model|controller> <name> Generate components
+          generate frontend <react|vue|svelte>        Scaffold a frontend app
+          generate views <resource> [fields...]       Generate React pages for REST actions
+          generate environment <name>                 Create a new environment
+          routes [-g PATTERN] [-f json]               Show route definitions
+          tasks [-g PATTERN] [-a]                     List available rake tasks
+          -T [-g PATTERN] [-a]                        Alias for tasks
+          setup state                                 Create/select S3 state bucket
+          setup tables <env>                          Generate DynamoDB tables from schema
+          setup frontend <env>                        Generate S3 + CloudFront infrastructure
+          deploy frontend <env>                       Build and deploy frontend to AWS
+          init <env>                                  terraform init for environment
+          plan <env>                                  terraform plan for environment
+          apply <env>                                 terraform apply for environment
+          destroy <env>                               terraform destroy for environment
+          output <env>                                terraform output for environment
+          --version                                   Show Belt version
+
+        Rake Tasks:
+          Any rake task from your Gemfile dependencies can be run directly:
+            belt lambda:build_layer                   Run a rake task by name
+
+        Environment:
+          Set BELT_ENV to skip the <env> argument:
+            export BELT_ENV=wups
+            belt apply                  # uses BELT_ENV
+            belt apply dev01            # explicit arg wins
+
+        Examples:
+          belt new blog --frontend react
+          belt generate resource post title:string content:text status:string
+          belt generate frontend react
+          belt setup frontend wups
+          belt deploy frontend wups
+          belt apply wups
+          belt tasks                    # list all rake tasks
+          belt lambda:build_layer       # run a rake task directly
+      USAGE
+    end
+  end
+end

data/lib/belt/lambda_handler.rb

@@ -25,6 +25,22 @@ module Belt
 
     def self.included(base)
       base.instance_variable_set(:@belt_lambda_handler_included, true)
+
+      # Skip auto-registration in test environments to avoid stale paths
+      return if ENV['BELT_ENV'] == 'test' || ENV['RACK_ENV'] == 'test' || defined?(RSpec)
+
+      # Auto-register controllers directory relative to the including file's location
+      caller_file = caller_locations(1, 1)&.first&.path
+      return unless caller_file
+
+      controllers_dir = File.join(File.dirname(caller_file), 'controllers')
+      return unless File.directory?(controllers_dir)
+
+      Belt.controller_paths << controllers_dir
+      Dir.children(controllers_dir).each do |child|
+        subdir = File.join(controllers_dir, child)
+        Belt.controller_paths << subdir if File.directory?(subdir)
+      end
     end
 
     # API Gateway Lambda handler.

data/lib/belt/root.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Belt
+  def self.root
+    @root ||= detect_root
+  end
+
+  def self.root=(path)
+    @root = path
+  end
+
+  def self.detect_root
+    dir = Dir.pwd
+    loop do
+      return dir if File.exist?(File.join(dir, 'infrastructure/routes.tf.rb'))
+
+      parent = File.dirname(dir)
+      break if parent == dir
+
+      dir = parent
+    end
+    Dir.pwd
+  end
+
+  private_class_method :detect_root
+end