belt 0.1.0 → 0.1.2

data/lib/belt/cli/routes_command.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'optparse'
+require 'fileutils'
+require_relative '../route_dsl'
+require_relative '../table_inference'
+require_relative 'routes_command/schema_loader'
+require_relative 'routes_command/route_inference'
+
+module Belt
+  module CLI
+    class RoutesCommand
+      include SchemaLoader
+      include RouteInference
+
+      def self.run(args)
+        new(args).run
+      end
+
+      def initialize(args)
+        @options = {}
+        parse_options(args)
+      end
+
+      def run
+        routes_file = find_routes_file
+        abort 'Error: No routes file found. Expected infrastructure/routes.tf.rb' unless routes_file
+
+        dsl = load_routes(routes_file)
+        @table_inference = TableInference.new(@options[:tables_file])
+        routes = collect_routes(dsl)
+        routes = apply_grep(routes) if @options[:grep]
+
+        warn 'Warning: --output-dir has no effect without --namespace' if @options[:output_dir] && !@options[:namespace]
+
+        if @options[:namespace]
+          output_ruby(routes, @options[:namespace], routes_file)
+        elsif @options[:format] == 'json'
+          output = { routes: routes }
+          models = load_schema_models(routes_file)
+          output[:models] = models if models.any?
+          puts JSON.pretty_generate(output)
+        else
+          output_concise(routes)
+        end
+      end
+
+      private
+
+      def parse_options(args)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: belt routes [options]'
+
+          opts.on('-g', '--grep PATTERN', 'Filter routes matching pattern') do |pattern|
+            @options[:grep] = pattern
+          end
+
+          opts.on('-f', '--format FORMAT', 'Output format: concise (default), json') do |format|
+            @options[:format] = format
+          end
+
+          opts.on('--namespace NAMESPACE', 'Generate Ruby route files for NAMESPACE (or "all")') do |ns|
+            @options[:namespace] = ns
+          end
+
+          opts.on('--output-dir DIR', 'Output directory for generated files') do |dir|
+            @options[:output_dir] = dir
+          end
+
+          opts.on('--schema FILE', 'Path to schema.tf.rb for model definitions') do |file|
+            @options[:schema_file] = file
+          end
+
+          opts.on('--tables-file FILE', 'Path to Terraform file with DynamoDB table definitions') do |file|
+            @options[:tables_file] = file
+          end
+
+          opts.on('-h', '--help', 'Show this help') do
+            puts opts
+            exit
+          end
+        end.parse!(args)
+      end
+
+      def find_routes_file
+        path = 'infrastructure/routes.tf.rb'
+        File.exist?(path) ? path : nil
+      end
+
+      def load_routes(file)
+        # Reset schema builder for clean state
+        Belt.instance_variable_set(:@application, nil)
+
+        content = File.read(file)
+        if content.include?('Belt.application.routes.draw')
+          binding_context = binding
+          eval(content, binding_context, file) # rubocop:disable Security/Eval
+        else
+          Belt::RouteDSL.load_from_file(file)
+        end
+      end
+
+      def collect_routes(dsl)
+        routes = []
+        dsl.api_gateways.each do |gateway|
+          gateway.routes.each do |route|
+            routes << build_route_hash(route, gateway)
+          end
+        end
+        routes.sort_by { |r| route_specificity(r[:path], r[:verb]) }
+      end
+
+      def build_route_hash(route, gateway)
+        hash = {
+          name: extract_route_name(route.path),
+          verb: route.method,
+          path: normalize_path(route.path),
+          gateway: gateway.name,
+          lambda: route.lambda.to_s,
+          controller: infer_controller(route, gateway),
+          action: infer_action(route, gateway),
+          auth: route.auth.to_s,
+          tables: get_route_tables(route),
+          request_model: route.request_model.to_s,
+          response_model: route.response_model.to_s
+        }
+        rc = route.response_context.to_s
+        hash[:response_context] = rc unless rc.empty?
+        hash
+      end
+
+      def get_route_tables(route)
+        if route.tables.any?
+          route.tables.map(&:to_s)
+        else
+          @table_inference.infer_tables_from_route(route)
+        end
+      end
+
+      def extract_route_name(path)
+        segments = path.split('/').reject(&:empty?)
+        return 'root' if segments.empty?
+
+        segments.reject { |s| s.start_with?('{', ':') }
+                .map { |s| s.gsub('-', '_') }
+                .join('_')
+      end
+
+      def output_ruby(routes, namespace, _routes_file)
+        output_dir = @options[:output_dir] || File.join(Belt.root, 'lambda/lib/routes')
+        FileUtils.mkdir_p(output_dir)
+        puts "Writing to #{output_dir}/:"
+
+        if namespace == 'all'
+          generate_all_manifests(routes, output_dir)
+        else
+          # Generate gateway-based manifest (all routes for this gateway)
+          filtered = routes.select { |r| r[:gateway] == namespace }
+          # Fall back to lambda-based if no gateway match
+          filtered = routes.select { |r| r[:lambda] == namespace } if filtered.empty?
+          if filtered.empty?
+            warn "No routes found for namespace '#{namespace}' - skipping"
+            return
+          end
+          write_ruby_manifest(filtered, namespace, output_dir)
+        end
+      end
+
+      def generate_all_manifests(routes, output_dir)
+        # Gateway-based manifests (primary — used by main Lambda entry points)
+        by_gateway = routes.group_by { |r| r[:gateway] }
+        by_gateway.each { |gw, gw_routes| write_ruby_manifest(gw_routes, gw, output_dir) }
+
+        # Scoped lambda manifests (where lambda != gateway — separate Lambda functions)
+        scoped = routes.reject { |r| r[:lambda] == r[:gateway] }
+        by_lambda = scoped.group_by { |r| r[:lambda] }
+        by_lambda.each { |lam, lam_routes| write_ruby_manifest(lam_routes, lam, output_dir) }
+      end
+
+      def write_ruby_manifest(routes, name, output_dir)
+        output_file = File.join(output_dir, "#{name}_routes.rb")
+        content = generate_ruby_content(routes, name)
+        File.write(output_file, content)
+        puts "  ✅ #{name}_routes.rb (#{routes.length} routes)"
+      end
+
+      def generate_ruby_content(routes, namespace)
+        constant_name = namespace.upcase
+        lines = [
+          '# frozen_string_literal: true',
+          '',
+          "# Auto-generated by: belt routes --namespace #{namespace}",
+          '# Do not edit manually',
+          '',
+          'module Routes',
+          "  #{constant_name} = ["
+        ]
+
+        routes.each_with_index do |route, index|
+          lines << '    {'
+          lines << "      verb: #{route[:verb].inspect},"
+          lines << "      path: #{route[:path].inspect},"
+          lines << "      gateway: #{route[:gateway].inspect},"
+          lines << "      lambda: #{route[:lambda].inspect},"
+          lines << "      controller: #{route[:controller].inspect},"
+          lines << "      action: #{route[:action].inspect},"
+          lines << "      auth: #{route[:auth].inspect},"
+          tables_syms = route[:tables].map { |t| ":#{t}" }.join(', ')
+          lines << "      tables: [#{tables_syms}]"
+          lines << "    }#{',' if index < routes.length - 1}"
+        end
+
+        lines << '  ].freeze'
+        lines << 'end'
+        lines << ''
+        lines.join("\n")
+      end
+
+      def normalize_path(path)
+        path = "/#{path}" unless path.start_with?('/')
+        normalized = path.gsub(%r{/([a-zA-Z_][a-zA-Z0-9_]*?)/:id(/|$)}) do
+          resource = ::Regexp.last_match(1)
+          trailing = ::Regexp.last_match(2)
+          singular = singularize(resource)
+          "/#{resource}/{#{singular}_id}#{trailing}"
+        end
+        normalized.gsub(/:([a-zA-Z_][a-zA-Z0-9_]*)/) { "{#{::Regexp.last_match(1)}}" }
+      end
+
+      def apply_grep(routes)
+        pattern = Regexp.new(@options[:grep], Regexp::IGNORECASE)
+        routes.select do |r|
+          r[:path].match?(pattern) ||
+            r[:gateway].to_s.match?(pattern) ||
+            r[:lambda].match?(pattern) ||
+            r[:verb].match?(pattern) ||
+            r[:controller].match?(pattern) ||
+            r[:action].match?(pattern)
+        end
+      end
+
+      def output_concise(routes)
+        return puts('No routes defined.') if routes.empty?
+
+        multi_gateway = routes.map { |r| r[:gateway] }.uniq.length > 1
+        verb_w = [routes.map { |r| r[:verb].length }.max, 6].max
+        path_w = [routes.map { |r| r[:path].length }.max, 4].max
+
+        if multi_gateway
+          output_concise_multi_gateway(routes, verb_w, path_w)
+        else
+          output_concise_single_gateway(routes, verb_w, path_w)
+        end
+      end
+
+      def output_concise_multi_gateway(routes, verb_w, path_w)
+        gw_w = [routes.map { |r| r[:gateway].to_s.length }.max, 7].max
+        lam_w = [routes.map { |r| r[:lambda].length }.max, 6].max
+
+        header = "#{'VERB'.ljust(verb_w)}  #{'PATH'.ljust(path_w)}  " \
+                 "#{'GATEWAY'.ljust(gw_w)}  #{'LAMBDA'.ljust(lam_w)}  CONTROLLER#ACTION"
+        puts header
+        puts '-' * (verb_w + path_w + gw_w + lam_w + 20)
+
+        routes.each do |r|
+          line = "#{r[:verb].ljust(verb_w)}  #{r[:path].ljust(path_w)}  " \
+                 "#{r[:gateway].to_s.ljust(gw_w)}  #{r[:lambda].ljust(lam_w)}  " \
+                 "#{r[:controller]}##{r[:action]}"
+          puts line
+        end
+      end
+
+      def output_concise_single_gateway(routes, verb_w, path_w)
+        puts "#{'VERB'.ljust(verb_w)}  #{'PATH'.ljust(path_w)}  CONTROLLER#ACTION"
+        puts '-' * (verb_w + path_w + 30)
+
+        routes.each do |r|
+          puts "#{r[:verb].ljust(verb_w)}  #{r[:path].ljust(path_w)}  #{r[:controller]}##{r[:action]}"
+        end
+      end
+
+      def route_specificity(path, verb)
+        segments = path.split('/').reject(&:empty?)
+        param_count = segments.count { |s| s.start_with?('{') }
+        segment_count = segments.length
+        [param_count, -segment_count, path, verb_order(verb)]
+      end
+
+      def verb_order(verb)
+        { 'GET' => 0, 'POST' => 1, 'PUT' => 2, 'PATCH' => 3, 'DELETE' => 4 }[verb] || 99
+      end
+
+      def singularize(word)
+        if word.end_with?('ies')
+          "#{word[0..-4]}y"
+        elsif word.end_with?('ses') || word.end_with?('xes') || word.end_with?('zes')
+          word[0..-3]
+        elsif word.end_with?('s') && !word.end_with?('ss')
+          word[0..-2]
+        else
+          word
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/tables_command.rb

@@ -59,8 +59,8 @@ module Belt
         schema_content = File.read(SCHEMA_FILE)
 
         # Replace DSL wrapper with direct parser call
-        # TerraDispatch.schema.draw do ... end → parser.instance_eval do ... end
-        inner = schema_content.sub(/\ATerraDispatch\.schema\.draw do\n?/, '').sub(/\nend\s*\z/, '')
+        # Belt.application.schema.draw do ... end → parser.instance_eval do ... end
+        inner = schema_content.sub(/\A(?:Belt\.application)\.schema\.draw do\n?/, '').sub(/\nend\s*\z/, '')
         parser.instance_eval(inner, SCHEMA_FILE)
         parser.models
       end

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.rb

@@ -1,6 +1,7 @@
 # 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'
@@ -10,13 +11,18 @@ 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'
+require_relative 'cli/console_command'
 
 module Belt
   module CLI
-    COMMANDS = {
+    COMMANDS_DEFINITION = {
       'new' => Belt::CLI::NewCommand,
-      'generate' => Belt::CLI::GenerateCommand,
-      'g' => Belt::CLI::GenerateCommand,
+      %w[generate g] => Belt::CLI::GenerateCommand,
+      'routes' => Belt::CLI::RoutesCommand,
+      %w[console c] => Belt::CLI::ConsoleCommand,
+      %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
       'setup' => Belt::CLI::SetupCommand,
       'deploy' => lambda { |args|
         subcommand = args.shift
@@ -27,10 +33,13 @@ module Belt
           exit 1
         end
       },
-      '--version' => ->(_args) { puts "Belt #{Belt::VERSION}" },
-      '-v' => ->(_args) { puts "Belt #{Belt::VERSION}" }
+      %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)
@@ -46,7 +55,10 @@ module Belt
 
       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
@@ -68,6 +80,11 @@ module Belt
           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
+          console                                     Start an interactive console (IRB)
+          c                                           Alias for console
+          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
@@ -79,6 +96,10 @@ module Belt
           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
@@ -92,6 +113,8 @@ module Belt
           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

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