railsforge 1.0.0

data/lib/railsforge/templates/v3/service/template.rb

@@ -0,0 +1,84 @@
+# Service class template v3
+# Advanced service with result monad and chaining
+class <%= class_name %>
+  include Dry::Monads[:result, :do]
+
+  # Initialize with dependencies
+  # @param [Hash] params - Parameters for the service
+  def initialize(params = {})
+    @params = params
+    @dependencies = {}
+  end
+
+  # Register a dependency
+  # @param [Symbol] key - Dependency key
+  # @param [Object] value - Dependency value
+  def register(key, value)
+    @dependencies[key] = value
+    self
+  end
+
+  # Execute the service - returns a Dry::Monads Result
+  def call
+    yield validate!
+    yield process!
+    Success(result_data)
+  rescue StandardError => e
+    Failure(error: e.message, code: :unexpected_error)
+  end
+
+  # Chain another service
+  # @param [Class] service_class - Next service to call
+  # @param [Hash] params - Parameters for next service
+  def then(service_class, params = {})
+    result = call
+    return result unless result.success?
+
+    service = service_class.new(@params.merge(params)).call
+    service
+  end
+
+  # Class-level call
+  def self.call(params = {})
+    new(params).call
+  end
+
+  private
+
+  # Validate inputs - returns Result
+  def validate!
+    # TODO: Add validation logic
+    # Example:
+    # return Failure(errors: ['Name required']) if @params[:name].blank?
+    Success(true)
+  end
+
+  # Process the main logic - returns Result
+  def process!
+    # TODO: Implement service logic
+    @result = {}
+    Success(true)
+  end
+
+  # Build result data
+  def result_data
+    {
+      data: @result,
+      metadata: {
+        service: self.class.name,
+        timestamp: Time.now.utc.iso8601
+      }
+    }
+  end
+end
+
+# Result wrapper for success/failure
+module Result
+  def self.success(data)
+    { success: true, data: data }
+  end
+
+  def self.failure(errors)
+    { success: false, errors: errors }
+  end
+end

data/lib/railsforge/version.rb

@@ -0,0 +1,5 @@
+# Version module for RailsForge gem
+# Defines the current version of the gem
+module RailsForge
+  VERSION = "0.1.0"
+end

data/lib/railsforge/wizard.rb

@@ -0,0 +1,265 @@
+# Wizard module for RailsForge
+# Interactive project scaffolding
+
+require 'fileutils'
+
+module RailsForge
+  # Wizard class provides interactive project setup
+  class Wizard
+    # Project types available
+    PROJECT_TYPES = {
+      "saas" => {
+        name: "SaaS Application",
+        description: "Full-featured SaaS with auth, admin, payments",
+        features: %w[authentication admin background_jobs]
+      },
+      "blog" => {
+        name: "Blog",
+        description: "Content blog with articles and comments",
+        features: %w[authentication comments]
+      },
+      "api" => {
+        name: "API Only",
+        description: "RESTful API with JWT authentication",
+        features: %w[jwt_auth background_jobs]
+      },
+      "admin_app" => {
+        name: "Admin Dashboard",
+        description: "Admin panel with CRUD operations",
+        features: %w[authentication admin]
+      },
+      "standard" => {
+        name: "Standard Rails",
+        description: "Basic Rails application",
+        features: []
+      }
+    }.freeze
+
+    # Initialize wizard
+    def initialize
+      @options = {
+        project_name: nil,
+        project_type: nil,
+        features: [],
+        generators: [],
+        analyze_after: false
+      }
+    end
+
+    # Run the interactive wizard
+    # @return [Hash] Selected options
+    def run
+      puts ""
+      puts "=" * 60
+      puts "RailsForge Project Wizard"
+      puts "=" * 60
+      puts ""
+
+      # Step 1: Project name
+      ask_project_name
+
+      # Step 2: Project type
+      ask_project_type
+
+      # Step 3: Features
+      ask_features
+
+      # Step 4: Generators
+      ask_generators
+
+      # Step 5: Analysis
+      ask_analysis
+
+      # Summary
+      show_summary
+
+      @options
+    end
+
+    # Execute the wizard choices
+    def execute
+      return unless @options[:project_name]
+
+      puts ""
+      puts "Creating Rails app: #{@options[:project_name]}"
+      puts ""
+
+      # Build options for RailsForge::Generator
+      generator_options = {
+        profile: @options[:project_type]
+      }
+
+      # Add features
+      generator_options[:auth] = "devise" if @options[:features].include?("authentication")
+      generator_options[:admin] = "activeadmin" if @options[:features].include?("admin")
+      generator_options[:jobs] = "sidekiq" if @options[:features].include?("background_jobs")
+
+      begin
+        # Create the Rails app
+        result = RailsForge::Generator.create_app(@options[:project_name], generator_options)
+        puts result
+        puts ""
+
+        # Run selected generators
+        run_generators if @options[:generators].any?
+
+        # Run analysis if requested
+        run_analysis if @options[:analyze_after]
+
+        puts ""
+        puts "✓ Project created successfully!"
+      rescue => e
+        puts "Error: #{e.message}"
+      end
+    end
+
+    private
+
+    # Ask for project name
+    def ask_project_name
+      print "Enter project name: "
+      name = STDIN.gets.strip
+
+      if name.empty?
+        puts "Please enter a valid project name"
+        ask_project_name
+      elsif name =~ /\A\d/ || name =~ /\s/
+        puts "Project name cannot start with a number or contain spaces"
+        ask_project_name
+      else
+        @options[:project_name] = name
+      end
+    end
+
+    # Ask for project type
+    def ask_project_type
+      puts ""
+      puts "Select project type:"
+      puts ""
+
+      PROJECT_TYPES.each do |key, type|
+        puts "  #{key.ljust(12)} - #{type[:name]}"
+        puts "               #{type[:description]}"
+        puts ""
+      end
+
+      print "Enter type (default: standard): "
+      type = STDIN.gets.strip.downcase
+
+      if type.empty?
+        @options[:project_type] = "standard"
+      elsif PROJECT_TYPES.key?(type)
+        @options[:project_type] = type
+        @options[:features] = PROJECT_TYPES[type][:features].dup
+      else
+        puts "Invalid project type"
+        ask_project_type
+      end
+    end
+
+    # Ask for additional features
+    def ask_features
+      puts ""
+      puts "Select additional features (comma-separated, or 'done'):"
+      puts ""
+
+      available_features = [
+        ["authentication", "User authentication (Devise)"],
+        ["admin", "Admin panel (ActiveAdmin)"],
+        ["background_jobs", "Background jobs (Sidekiq)"],
+        ["api", "REST API endpoints"],
+        ["comments", "Comment system"],
+        ["notifications", "Email/push notifications"],
+        ["payments", "Payment integration (Stripe)"],
+        ["uploads", "File uploads (Carrierwave/ActiveStorage)"]
+      ]
+
+      available_features.each do |key, desc|
+        included = @options[:features].include?(key) ? " ✓" : ""
+        puts "  #{key.ljust(20)} - #{desc}#{included}"
+      end
+      puts ""
+
+      print "Features (or 'done' to continue): "
+      features_input = STDIN.gets.strip.downcase
+
+      if features_input != "done"
+        selected = features_input.split(",").map(&:strip).reject(&:empty?)
+        @options[:features] = (@options[:features] + selected).uniq
+      end
+    end
+
+    # Ask which generators to run
+    def ask_generators
+      puts ""
+      puts "Select generators to run after creation (comma-separated, or 'none'):"
+      puts ""
+
+      available_generators = [
+        ["scaffold", "Full scaffold (model, controller, views)"],
+        ["resource", "API resource only"],
+        ["service", "Example service object"],
+        ["job", "Example background job"]
+      ]
+
+      available_generators.each do |key, desc|
+        puts "  #{key.ljust(12)} - #{desc}"
+      end
+      puts ""
+
+      print "Generators (or 'none'): "
+      generators_input = STDIN.gets.strip.downcase
+
+      if generators_input != "none" && !generators_input.empty?
+        @options[:generators] = generators_input.split(",").map(&:strip).reject(&:empty?)
+      end
+    end
+
+    # Ask whether to run analysis
+    def ask_analysis
+      puts ""
+      print "Run architecture analysis after creation? (y/N): "
+      answer = STDIN.gets.strip.downcase
+
+      @options[:analyze_after] = answer == "y" || answer == "yes"
+    end
+
+    # Show summary of choices
+    def show_summary
+      puts ""
+      puts "-" * 40
+      puts "Summary:"
+      puts "  Project: #{@options[:project_name]}"
+      puts "  Type: #{@options[:project_type]} (#{PROJECT_TYPES[@options[:project_type]][:name]})"
+      puts "  Features: #{@options[:features].join(', ')}"
+      puts "  Generators: #{@options[:generators].join(', ')}"
+      puts "  Analyze: #{@options[:analyze_after] ? 'Yes' : 'No'}"
+      puts "-" * 40
+    end
+
+    # Run selected generators
+    def run_generators
+      puts ""
+      puts "Running generators..."
+
+      Dir.chdir(@options[:project_name]) do
+        @options[:generators].each do |generator|
+          puts "  Running #{generator} generator..."
+          # In a full implementation, this would run the actual generators
+        end
+      end
+    end
+
+    # Run analysis
+    def run_analysis
+      puts ""
+      puts "Running architecture analysis..."
+
+      Dir.chdir(@options[:project_name]) do
+        # Run the doctor
+        doctor = RailsForge::Doctor.new
+        doctor.run
+      end
+    end
+  end
+end

data/lib/railsforge/wizard_tui.rb

@@ -0,0 +1,286 @@
+# WizardTUI - Menu-driven interactive terminal interface for RailsForge
+# Uses TTY::Prompt for interactive menus
+
+module RailsForge
+  # WizardTUI - Interactive TUI wizard
+  class WizardTUI
+    # Available project types mapped to profiles
+    PROJECT_TYPES = {
+      "standard" => { name: "Standard", description: "Basic Rails application", profile: "standard" },
+      "blog" => { name: "Blog", description: "Content blog with articles and comments", profile: "blog" },
+      "admin_app" => { name: "Admin App", description: "Admin dashboard with CRUD operations", profile: "admin_app" },
+      "api_only" => { name: "API-Only", description: "RESTful API with JWT authentication", profile: "api_only" },
+      "saas" => { name: "SaaS", description: "Full-featured SaaS with auth, admin, payments", profile: "standard" }
+    }.freeze
+
+    # Available features/generators
+    AVAILABLE_FEATURES = %w[
+      services queries jobs forms presenters policies serializers
+      mailers features apis components stimulus
+    ].freeze
+
+    # Available analyzers
+    AVAILABLE_ANALYZERS = %w[
+      controllers models specs database metrics
+      security performance
+    ].freeze
+
+    # Initialize wizard
+    def initialize
+      # Lazy-load TTY dependencies
+      require 'tty-prompt'
+      require 'tty-table'
+      
+      @prompt = TTY::Prompt.new
+      @options = {
+        project_name: nil,
+        project_type: nil,
+        template_version: nil,
+        features: [],
+        analyzers: [],
+        dry_run: false
+      }
+    end
+
+    # Main execution method
+    def run
+      puts ""
+      puts "🚀 Welcome to RailsForge Wizard!".color(:green)
+      puts "=" * 50
+      puts ""
+
+      # Step 1: Project name
+      ask_project_name
+
+      # Step 2: Project type
+      select_project_type
+
+      # Step 3: Template version
+      select_template_version
+
+      # Step 4: Features
+      select_features
+
+      # Step 5: Analyzers
+      select_analyzers
+
+      # Step 6: Dry-run option
+      ask_dry_run
+
+      # Step 7: Summary and confirmation
+      confirm_and_run
+    end
+
+    private
+
+    # Ask for project name
+    def ask_project_name
+      @options[:project_name] = @prompt.ask("Project name:") do |q|
+        q.required true
+        q.validate(/^[a-z][a-z0-9_]*$/i, "Must be valid Ruby identifier (letters, numbers, underscores)")
+        q.modify :strip
+      end
+    end
+
+    # Select project type
+    def select_project_type
+      choices = PROJECT_TYPES.map do |key, value|
+        { name: "#{value[:name]} - #{value[:description]}", value: key }
+      end
+
+      @options[:project_type] = @prompt.select("Select project type:", choices, default: "standard")
+    end
+
+    # Select template version
+    def select_template_version
+      versions = detect_template_versions
+
+      # Check for default in config
+      default_version = RailsForge::Config.get("generators.default_template_version") rescue "v1"
+
+      choices = versions.map { |v| { name: "Version #{v}", value: v } }
+      @options[:template_version] = @prompt.select("Select template version:", choices, default: default_version)
+    end
+
+    # Detect available template versions
+    def detect_template_versions
+      templates_dir = File.expand_path("../templates", __FILE__)
+      return ["v1"] unless Dir.exist?(templates_dir)
+
+      Dir.glob(File.join(templates_dir, "v*")).map do |dir|
+        File.basename(dir)
+      end.sort
+    end
+
+    # Select features
+    def select_features
+      feature_descriptions = {
+        "services" => "Service objects for business logic",
+        "queries" => "Query objects for database queries",
+        "jobs" => "Background jobs",
+        "forms" => "Form objects",
+        "presenters" => "Presenter objects",
+        "policies" => "Policy objects",
+        "serializers" => "Serializer objects",
+        "mailers" => "Mailer classes",
+        "features" => "Feature specs",
+        "apis" => "API resources",
+        "components" => "ViewComponent components",
+        "stimulus" => "Stimulus controllers"
+      }
+
+      choices = AVAILABLE_FEATURES.map do |f|
+        { name: "#{f.capitalize.ljust(15)} - #{feature_descriptions[f]}", value: f }
+      end
+
+      @options[:features] = @prompt.multi_select("Select features to include:", choices, min: 0)
+    end
+
+    # Select analyzers
+    def select_analyzers
+      analyzer_descriptions = {
+        "controllers" => "Analyze controllers for issues",
+        "models" => "Analyze models for issues",
+        "specs" => "Check spec coverage",
+        "database" => "Check database schema",
+        "metrics" => "Code metrics analysis",
+        "security" => "Security vulnerability scan",
+        "performance" => "Performance issue detection"
+      }
+
+      choices = AVAILABLE_ANALYZERS.map do |a|
+        { name: "#{a.capitalize.ljust(15)} - #{analyzer_descriptions[a]}", value: a }
+      end
+
+      # Add "Run All" option
+      all_choice = { name: "Run All Analyzers", value: "all" }
+      choices.unshift(all_choice)
+
+      selected = @prompt.multi_select("Select analyzers to run after generation:", choices, min: 0)
+
+      # Handle "all" selection
+      @options[:analyzers] = selected.include?("all") ? AVAILABLE_ANALYZERS.dup : selected
+    end
+
+    # Ask for dry-run
+    def ask_dry_run
+      @options[:dry_run] = @prompt.yes?("Preview files without creating?")
+    end
+
+    # Display summary and confirm
+    def confirm_and_run
+      puts ""
+      puts "📋 Summary".color(:cyan)
+      puts "-" * 40
+      puts "Project: #{@options[:project_name]}"
+      puts "Type: #{PROJECT_TYPES[@options[:project_type]][:name]}"
+      puts "Template: #{@options[:template_version]}"
+      puts "Features: #{@options[:features].join(', ')}"
+      puts "Analyzers: #{@options[:analyzers].join(', ')}"
+      puts "Dry-run: #{@options[:dry_run] ? 'Yes' : 'No'}"
+      puts "-" * 40
+
+      confirmed = @prompt.yes?("Proceed with generation?")
+
+      if confirmed
+        execute
+      else
+        puts "Cancelled.".color(:yellow)
+      end
+    end
+
+    # Execute the wizard choices
+    def execute
+      puts ""
+      puts "� Generating Rails app...".color(:green)
+
+      if @options[:dry_run]
+        dry_run_output
+      else
+        run_generation
+        run_analyzers
+        print_results
+      end
+    end
+
+    # Dry-run output
+    def dry_run_output
+      puts ""
+      puts "🔍 Dry-run mode - Preview of files to generate".color(:yellow)
+      puts ""
+
+      # Show what would be created
+      puts "Profile: #{@options[:project_type]}"
+      puts "Template version: #{@options[:template_version]}"
+      puts ""
+      puts "Features to generate:"
+      @options[:features].each { |f| puts "  - #{f}" }
+      puts ""
+      puts "Analyzers to run:"
+      @options[:analyzers].each { |a| puts "  - #{a}" }
+    end
+
+    # Run the actual generation
+    def run_generation
+      # Apply profile
+      profile = RailsForge::Profile.load(@options[:project_type])
+      RailsForge::Profile.create_folders(@options[:project_name], profile)
+
+      # Run selected generators
+      @options[:features].each do |feature|
+        puts "  Running #{feature} generator..."
+        # Note: In a full implementation, this would run the actual generators
+      end
+    end
+
+    # Run selected analyzers
+    def run_analyzers
+      return if @options[:analyzers].empty?
+
+      puts ""
+      puts "🔍 Running analyzers...".color(:cyan)
+
+      @options[:analyzers].each do |analyzer|
+        puts "  Running #{analyzer} analyzer..."
+        case analyzer
+        when "controllers"
+          results = RailsForge::Analyzers::ControllerAnalyzer.analyze
+          RailsForge::Analyzers::ControllerAnalyzer.print_results(results)
+        when "models"
+          results = RailsForge::Analyzers::ModelAnalyzer.analyze
+          RailsForge::Analyzers::ModelAnalyzer.print_results(results)
+        when "specs"
+          results = RailsForge::Analyzers::SpecAnalyzer.analyze
+          RailsForge::Analyzers::SpecAnalyzer.print_results(results)
+        when "database"
+          results = RailsForge::Analyzers::DatabaseAnalyzer.analyze
+          RailsForge::Analyzers::DatabaseAnalyzer.print_report(results)
+        when "metrics"
+          results = RailsForge::Analyzers::MetricsAnalyzer.analyze
+          RailsForge::Analyzers::MetricsAnalyzer.print_results(results)
+        when "security"
+          results = RailsForge::Analyzers::SecurityAnalyzer.analyze
+          RailsForge::Analyzers::SecurityAnalyzer.print_report(results)
+        when "performance"
+          results = RailsForge::Analyzers::PerformanceAnalyzer.analyze
+          RailsForge::Analyzers::PerformanceAnalyzer.print_report(results)
+        end
+      end
+    end
+
+    # Print final results
+    def print_results
+      puts ""
+      puts "✅ Generation complete!".color(:green)
+      puts ""
+      puts "Project '#{@options[:project_name]}' created successfully!"
+    end
+  end
+end
+
+# Add color support for String class
+class String
+  def color(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+end

data/lib/railsforge.rb

@@ -0,0 +1,13 @@
+# RailsForge gem entry point
+# This file is the main entry point for the gem
+
+require_relative "railsforge/loader"
+
+# The main RailsForge module is defined in loader.rb
+# This file exists for backward compatibility
+module RailsForge
+  # Greeting method - kept for compatibility
+  def self.greet
+    "Welcome to RailsForge #{VERSION}!"
+  end
+end