railsforge 1.0.0

data/lib/railsforge/cli.rb

@@ -0,0 +1,671 @@
+# CLI module for RailsForge
+# Handles all CLI commands
+
+module RailsForge
+  # CLI class handles command-line interface
+  class CLI
+    # Main entry point
+    def self.start(args)
+      command = args.shift
+
+      case command
+      when "new"
+        handle_new_command(args)
+      when "generate", "g"
+        handle_generate_command(args)
+      when "analyze", "a"
+        handle_analyze_command(args)
+      when "refactor", "r"
+        handle_refactor_command(args)
+      when "doctor"
+        handle_doctor_command(args)
+      when "audit"
+        handle_audit_command(args)
+      when "graph"
+        handle_graph_command(args)
+      when "wizard", "wiz"
+        handle_wizard_command(args)
+      when "plugins", "plug"
+        handle_plugins_command(args)
+      when "config", "cfg"
+        handle_config_command(args)
+      when "profiles"
+        puts RailsForge::Profile.show_available
+      when "--version", "-v"
+        puts "RailsForge #{VERSION}"
+      when nil, "--help", "-h"
+        display_help
+      else
+        puts "Unknown command: #{command}"
+        display_help
+        exit 1
+      end
+    end
+
+    # Display help
+    def self.display_help
+      puts <<~HELP
+        RailsForge - A Rails development toolkit
+
+        Usage:
+          railsforge new <app_name>              Create a new Rails app
+          railsforge generate service <name>    Generate a service object
+          railsforge generate query <name>      Generate a query object
+          railsforge generate job <name>        Generate a job object
+          railsforge generate demo <name>       Generate a demo project
+          railsforge generate devops            Generate Docker/CI-CD configs
+          railsforge generate monitoring         Generate Sentry/Lograge configs
+          railsforge generate test <name>        Generate test files
+          railsforge analyze                    Analyze code quality
+          railsforge doctor                     Full project health check
+          railsforge audit                      Architecture audit
+          railsforge graph                      Dependency graph
+          railsforge refactor                   Refactoring suggestions
+          railsforge wizard                     Interactive project setup
+          railsforge plugins                    Plugin management
+          railsforge config                     Configuration
+          railsforge profiles                   List available profiles
+          railsforge --version, -v              Show version
+          railsforge --help, -h                 Show this help
+      HELP
+    end
+
+    # Handle new command
+    def self.handle_new_command(args)
+      options = {}
+      app_name = nil
+      interactive = true
+
+      args.each do |arg|
+        if arg.start_with?("--")
+          key, value = arg[2..].split("=", 2)
+          interactive = false
+          case key
+          when "auth"
+            options[:auth] = value || "devise"
+          when "admin"
+            options[:admin] = value || "activeadmin"
+          when "jobs"
+            options[:jobs] = value || "sidekiq"
+          when "profile"
+            options[:profile] = value
+          end
+        elsif !arg.start_with?("-") && app_name.nil?
+          app_name = arg
+        end
+      end
+
+      if app_name.nil?
+        puts "Usage: railsforge new <app_name> [options]"
+        exit 1
+      end
+
+      if interactive
+        options = prompt_for_features(app_name)
+      end
+
+      begin
+        result = RailsForge::Generator.create_app(app_name, options)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Prompt for features
+    def self.prompt_for_features(app_name)
+      options = {}
+      puts "\n#{'=' * 50}"
+      puts "RailsForge Interactive Setup"
+      puts "#{'=' * 50}"
+
+      if prompt_yes_no("Add authentication?")
+        options[:auth] = "devise"
+      end
+
+      if prompt_yes_no("Add admin panel?")
+        options[:admin] = "activeadmin"
+      end
+
+      if prompt_yes_no("Add background jobs?")
+        options[:jobs] = "sidekiq"
+      end
+
+      options
+    end
+
+    # Prompt yes/no
+    def self.prompt_yes_no(question, default: false)
+      suffix = default ? " [Y/n]" : " [y/N]"
+      print "#{question}#{suffix}: "
+      answer = STDIN.gets.strip.downcase
+      return default if answer.empty?
+      answer == "y" || answer == "yes"
+    end
+
+    # Handle generate command
+    def self.handle_generate_command(args)
+      template_version = "v1"
+      dry_run = false
+      
+      # Parse options
+      args = args.reject do |arg|
+        if arg.start_with?("--template=")
+          template_version = arg.split("=").last
+          true
+        elsif arg == "--dry-run"
+          dry_run = true
+          true
+        else
+          false
+        end
+      end
+
+      generator_type = args.shift
+      names = args  # Multiple names allowed for bulk generation
+
+      # Generators that don't require names
+      no_name_generators = ["devops", "ops", "monitoring", "mon"]
+      
+      # Handle bulk generation
+      if names.empty? && generator_type && !no_name_generators.include?(generator_type)
+        puts "Error: Name required"
+        exit 1
+      end
+
+      case generator_type
+      when "service", "s"
+        handle_generate_bulk(:service, names, template_version, dry_run)
+      when "query", "q"
+        handle_generate_bulk(:query, names, template_version, dry_run)
+      when "job", "j"
+        handle_generate_bulk(:job, names, template_version, dry_run)
+      when "form", "f"
+        handle_generate_bulk(:form, names, template_version, dry_run)
+      when "presenter", "p"
+        handle_generate_bulk(:presenter, names, template_version, dry_run)
+      when "policy", "pol"
+        handle_generate_bulk(:policy, names, template_version, dry_run)
+      when "serializer", "ser"
+        handle_generate_bulk(:serializer, names, template_version, dry_run)
+      when "component", "c"
+        handle_generate_bulk(:component, names, template_version, dry_run)
+      when "stimulus", "stim"
+        handle_generate_bulk(:stimulus, names, template_version, dry_run)
+      when "demo"
+        handle_generate_demo(args, names.first)
+      when "devops", "ops"
+        handle_generate_devops(args)
+      when "monitoring", "mon"
+        handle_generate_monitoring(args)
+      when "test", "t"
+        handle_generate_test(args, names.first)
+      when "mailer", "mail"
+        handle_generate_bulk(:mailer, names, template_version, dry_run)
+      when "feature", "feat"
+        handle_generate_feature(args, names.first)
+      when "api"
+        handle_generate_api(args, names.first)
+      else
+        puts "Usage: railsforge generate <type> <name> [<name>...]"
+        puts "Types: service, query, job, form, presenter, policy, serializer, component, stimulus, mailer, feature, api"
+        puts "Options: --template=v2, --dry-run"
+        exit 1
+      end
+    end
+
+    # Handle bulk generation
+    def self.handle_generate_bulk(type, names, template_version, dry_run)
+      if dry_run
+        puts "Dry run - would generate:"
+        names.each { |name| puts "  - #{type}: #{name} (template: #{template_version})" }
+        return
+      end
+
+      results = []
+      names.each do |name|
+        result = generate_single(type, name, template_version)
+        results << result
+      end
+
+      puts results.join("\n")
+    end
+
+    # Generate a single item
+    def self.generate_single(type, name, template_version)
+      case type
+      when :service
+        "Generating service: #{name}" + "\n" + RailsForge::Generators::ServiceGenerator.generate(name, with_spec: true, template_version: template_version)
+      when :query
+        "Generating query: #{name}"
+      when :job
+        "Generating job: #{name}"
+      when :component
+        "Generating component: #{name}" + "\n" + RailsForge::Generators::ViewComponentGenerator.new(name, template_version: template_version).generate
+      when :stimulus
+        "Generating stimulus: #{name}" + "\n" + RailsForge::Generators::StimulusControllerGenerator.new(name, template_version: template_version).generate
+      else
+        "Generator for #{type} not fully implemented"
+      end
+    rescue => e
+      "Error generating #{name}: #{e.message}"
+    end
+
+    # Generate service
+    def self.handle_generate_service(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating service: #{name}..."
+        result = RailsForge::Generators::ServiceGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate query
+    def self.handle_generate_query(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating query: #{name}..."
+        result = RailsForge::Generators::QueryGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate job
+    def self.handle_generate_job(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating job: #{name}..."
+        result = RailsForge::Generators::JobGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate form
+    def self.handle_generate_form(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating form: #{name}..."
+        result = RailsForge::Generators::FormGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate presenter
+    def self.handle_generate_presenter(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating presenter: #{name}..."
+        result = RailsForge::Generators::PresenterGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate policy
+    def self.handle_generate_policy(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating policy: #{name}..."
+        result = RailsForge::Generators::PolicyGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate serializer
+    def self.handle_generate_serializer(args, name, template_version)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating serializer: #{name}..."
+        result = RailsForge::Generators::SerializerGenerator.generate(name, with_spec: with_spec, template_version: template_version)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate mailer
+    def self.handle_generate_mailer(args, name)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating mailer: #{name}..."
+        result = RailsForge::Generators::MailerGenerator.generate(name, with_spec: with_spec)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate feature
+    def self.handle_generate_feature(args, name)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating feature: #{name}..."
+        result = RailsForge::Generators::FeatureGenerator.generate(name, with_spec: with_spec)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate API
+    def self.handle_generate_api(args, name)
+      with_spec = !args.include?("--no-spec")
+
+      begin
+        puts "Generating API resource: #{name}..."
+        result = RailsForge::Generators::ApiGenerator.generate(name, with_spec: with_spec)
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate demo project
+    def self.handle_generate_demo(args, name)
+      options = {}
+      args.each do |arg|
+        if arg.start_with?("--")
+          key, value = arg[2..].split("=", 2)
+          options[key.to_sym] = value || true
+        end
+      end
+
+      begin
+        puts "Generating demo project: #{name}..."
+        result = RailsForge::Generators::DemoGenerator.new(name, options).generate
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate devops configs
+    def self.handle_generate_devops(args)
+      options = {}
+      args.each do |arg|
+        if arg.start_with?("--")
+          key, value = arg[2..].split("=", 2)
+          options[key.to_sym] = value || true
+        end
+      end
+
+      begin
+        puts "Generating DevOps configurations..."
+        result = RailsForge::Generators::DevopsGenerator.new("devops", options).generate
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate monitoring configs
+    def self.handle_generate_monitoring(args)
+      options = {}
+      args.each do |arg|
+        if arg.start_with?("--")
+          key, value = arg[2..].split("=", 2)
+          options[key.to_sym] = value || true
+        end
+      end
+
+      begin
+        puts "Generating Monitoring configurations..."
+        result = RailsForge::Generators::MonitoringGenerator.new("monitoring", options).generate
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Generate test files
+    def self.handle_generate_test(args, name)
+      options = { type: "model" }
+      args.each do |arg|
+        if arg.start_with?("--")
+          key, value = arg[2..].split("=", 2)
+          options[key.to_sym] = value || true
+        end
+      end
+
+      begin
+        puts "Generating test files for: #{name}..."
+        result = RailsForge::Generators::TestGenerator.new(name, options).generate
+        puts "\n#{result}"
+      rescue => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+
+    # Handle analyze command
+    def self.handle_analyze_command(args)
+      target = args.shift
+
+      case target
+      when nil, "controllers", "c"
+        analyze_controllers
+      when "models", "m"
+        analyze_models
+      when "specs", "spec", "s"
+        analyze_specs
+      when "db", "database", "d"
+        analyze_db
+      when "metrics", "metric", "met"
+        analyze_metrics(args)
+      when "security", "sec", "security"
+        analyze_security
+      when "performance", "perf", "p"
+        analyze_performance
+      when "all", "full", "a"
+        analyze_all
+      else
+        puts "Unknown analyze target: #{target}"
+        puts "Available: controllers, models, specs, db, metrics, security, performance, all"
+        exit 1
+      end
+    end
+
+    def self.analyze_security
+      results = RailsForge::Analyzers::SecurityAnalyzer.analyze
+      RailsForge::Analyzers::SecurityAnalyzer.print_report(results)
+    end
+
+    def self.analyze_performance
+      results = RailsForge::Analyzers::PerformanceAnalyzer.analyze
+      RailsForge::Analyzers::PerformanceAnalyzer.print_report(results)
+    end
+
+    def self.analyze_controllers
+      results = RailsForge::Analyzers::ControllerAnalyzer.analyze
+      RailsForge::Analyzers::ControllerAnalyzer.print_results(results)
+    end
+
+    def self.analyze_models
+      results = RailsForge::Analyzers::ModelAnalyzer.analyze
+      RailsForge::Analyzers::ModelAnalyzer.print_results(results)
+    end
+
+    def self.analyze_specs
+      results = RailsForge::Analyzers::SpecAnalyzer.analyze
+      RailsForge::Analyzers::SpecAnalyzer.print_results(results)
+    end
+
+    def self.analyze_db
+      results = RailsForge::Analyzers::DatabaseAnalyzer.analyze
+      RailsForge::Analyzers::DatabaseAnalyzer.print_report(results)
+    end
+
+    def self.analyze_metrics(args)
+      results = RailsForge::Analyzers::MetricsAnalyzer.analyze
+      RailsForge::Analyzers::MetricsAnalyzer.print_results(results)
+    end
+
+    def self.analyze_all
+      RailsForge::ReportFormatter.generate_report
+    end
+
+    # Handle refactor command
+    def self.handle_refactor_command(args)
+      target = args.shift
+
+      case target
+      when nil, "controllers", "c"
+        refactor_controllers
+      when "models", "m"
+        refactor_models
+      when "controller"
+        refactor_specific_controller(args.shift)
+      else
+        puts "Usage: railsforge refactor [controllers|models|controller <name>]"
+        exit 1
+      end
+    end
+
+    def self.refactor_controllers
+      results = RailsForge::Analyzers::RefactorAnalyzer.analyze_controllers
+      RailsForge::Analyzers::RefactorAnalyzer.print_report(results)
+    end
+
+    def self.refactor_models
+      results = RailsForge::Analyzers::RefactorAnalyzer.analyze_models
+      RailsForge::Analyzers::RefactorAnalyzer.print_report(results)
+    end
+
+    def self.refactor_specific_controller(name)
+      refactor = RailsForge::Refactors::RefactorController.new
+      refactor.refactor(name)
+    end
+
+    # Handle doctor command
+    def self.handle_doctor_command(args)
+      doctor = RailsForge::Doctor.new
+      doctor.run
+    rescue => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    # Handle audit command
+    def self.handle_audit_command(args)
+      results = RailsForge::Audit.run
+      RailsForge::Audit.print_report(results)
+    rescue => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    # Handle graph command
+    def self.handle_graph_command(args)
+      graph = RailsForge::Graph.new
+      graph.generate
+    rescue => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    # Handle wizard command
+    def self.handle_wizard_command(args)
+      # Check for --tty or --text flag
+      use_tty = !args.include?("--text") && ENV.fetch("FORCE_TTY", nil) != "false"
+      
+      # Try to use TTY wizard if available
+      if use_tty
+        begin
+          require "tty-prompt"
+          tui = RailsForge::WizardTUI.new
+          tui.run
+          return
+        rescue LoadError
+          puts "TTY::Prompt not available, falling back to text wizard..."
+        rescue => e
+          puts "Warning: TUI failed (#{e.message}), falling back..."
+        end
+      end
+      
+      # Fall back to text-based wizard
+      wizard = RailsForge::Wizard.new
+      options = wizard.run
+      print "\nCreate this project? (y/N): "
+      answer = STDIN.gets.strip.downcase
+      if answer == "y" || answer == "yes"
+        wizard.execute
+      else
+        puts "Cancelled."
+      end
+    rescue => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    # Handle plugins command
+    def self.handle_plugins_command(args)
+      action = args.shift
+
+      case action
+      when nil, "list", "ls"
+        RailsForge::Plugins.show_installed
+      when "load"
+        RailsForge::Plugins.load(args.shift)
+      when "create"
+        RailsForge::Plugins.create(args.shift)
+      else
+        puts "Usage: railsforge plugins [list|load|create]"
+      end
+    end
+
+    # Handle config command
+    def self.handle_config_command(args)
+      action = args.shift
+
+      case action
+      when nil, "show"
+        RailsForge::Config.show
+      when "init"
+        RailsForge::Config.init
+      when "get"
+        puts RailsForge::Config.get(args.shift)
+      when "set"
+        RailsForge::Config.set(args.shift, args.shift)
+      when "reset"
+        RailsForge::Config.reset
+      else
+        puts "Usage: railsforge config [show|init|get|set|reset]"
+      end
+    end
+  end
+end