railsforge 1.0.1 → 2.0.0

data/lib/railsforge/cli.rb

@@ -1,671 +1,49 @@
-# CLI module for RailsForge
-# Handles all CLI commands
+# CLI — RailsForge v2 command dispatcher
+# Supported commands: doctor
 
 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
+        puts "Run `railsforge --help` for usage."
         exit 1
       end
     end
 
-    # Display help
     def self.display_help
       puts <<~HELP
-        RailsForge - A Rails development toolkit
+        RailsForge — Rails application health diagnostics
 
         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
+          railsforge doctor                Run full diagnostic scan
+          railsforge doctor --format=json  Output as JSON
+          railsforge --version             Show version
+          railsforge --help                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
+      json   = args.include?("--format=json") || args.include?("--json")
+      result = RailsForge::Doctor.new.run
 
-    # 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
+      if json
+        puts RailsForge::Formatter.render_json(result[:issues], result[:score], result[:metrics])
       else
-        puts "Cancelled."
+        puts RailsForge::Formatter.render_text(result[:issues], result[:score])
       end
-    rescue => e
+    rescue RailsForge::Doctor::DoctorError => 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