railsforge 1.0.2 → 2.1.0

data/lib/railsforge/cli_minimal.rb

@@ -1,5 +1,5 @@
-# Minimal CLI for fast --help and --version
-# This is loaded first, then full CLI is lazy-loaded when needed
+# Minimal CLI — fast path for --help and --version.
+# All other commands load the full pipeline.
 
 module RailsForge
   class CLIMinimal
@@ -11,28 +11,10 @@ module RailsForge
         display_help
         exit 0
       when "--version", "-v"
-        # Only load version, nothing else
         require_relative "version"
         puts "RailsForge #{RailsForge::VERSION}"
         exit 0
       else
-        # Load full CLI for other commands - this is where the slowness comes from
-        require_relative "cli"
-        require_relative "profiles"
-        require_relative "template_loader"
-        require_relative "generator"
-        
-        # Load all generators
-        require_relative "generators/base_generator"
-        require_relative "generators/service_generator"
-        require_relative "generators/view_component_generator"
-        require_relative "generators/stimulus_controller_generator"
-        require_relative "generators/demo_generator"
-        require_relative "generators/devops_generator"
-        require_relative "generators/monitoring_generator"
-        require_relative "generators/test_generator"
-        
-        # Load all analyzers
         require_relative "analyzers/base_analyzer"
         require_relative "analyzers/controller_analyzer"
         require_relative "analyzers/model_analyzer"
@@ -42,51 +24,24 @@ module RailsForge
         require_relative "analyzers/refactor_analyzer"
         require_relative "analyzers/security_analyzer"
         require_relative "analyzers/performance_analyzer"
-        
-        # Load refactors and plugins
-        require_relative "refactors/refactor_controller"
-        require_relative "plugins"
-        
-        # Load legacy modules
-        require_relative "mailer_generator"
-        require_relative "feature_generator"
-        require_relative "api_generator"
-        require_relative "audit"
         require_relative "doctor"
-        require_relative "graph"
-        require_relative "wizard"
-        require_relative "wizard_tui"
-        require_relative "config"
+        require_relative "diff"
+        require_relative "cli"
 
-        # Dispatch to full CLI
         CLI.start([command] + args)
       end
     end
 
     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 diff <baseline.json> <current>  Show only new issues
+          railsforge --version                       Show version
+          railsforge --help                          Show this help
       HELP
     end
   end

data/lib/railsforge/diff.rb

@@ -0,0 +1,57 @@
+# Diff — compare two RailsForge JSON outputs and return only new issues.
+#
+# Usage:
+#   new_issues = RailsForge::Diff.run("baseline.json", "current.json")
+#
+# Two issues are considered equal when analyzer + type + file + line + message
+# all match. Severity and suggestion are intentionally ignored.
+
+require "json"
+
+module RailsForge
+  class Diff
+    class DiffError < StandardError; end
+
+    def self.run(baseline_path, current_path)
+      baseline = load_issues(baseline_path)
+      current  = load_issues(current_path)
+
+      baseline_fingerprints = baseline.map { |i| fingerprint(i) }
+
+      current.reject { |i| baseline_fingerprints.include?(fingerprint(i)) }
+    end
+
+    class << self
+      private
+
+      def load_issues(path)
+        raise DiffError, "File not found: #{path}" unless File.exist?(path)
+
+        raw = JSON.parse(File.read(path))
+        raise DiffError, "Invalid format: missing 'issues' key in #{path}" unless raw.key?("issues")
+
+        raw["issues"].map do |h|
+          RailsForge::Issue.new(
+            analyzer:   h["analyzer"]&.to_sym,
+            type:       h["type"]&.to_sym,
+            severity:   h["severity"],
+            file:       h["file"],
+            line:       h["line"],
+            message:    h["message"],
+            suggestion: h["suggestion"]
+          )
+        end
+      end
+
+      def fingerprint(issue)
+        [
+          issue.analyzer.to_s,
+          issue.type.to_s,
+          issue.file.to_s,
+          issue.line.to_s,
+          issue.message.to_s
+        ]
+      end
+    end
+  end
+end

data/lib/railsforge/doctor.rb

@@ -1,250 +1,77 @@
-# Doctor module for RailsForge
-# Provides a comprehensive project health report
+# Doctor — RailsForge v2 core orchestrator
+#
+# Responsibilities: run analyzers, collect issues, compute score, return result.
+# No output. No formatting. No printing.
+#
+# Final flow:
+#   CLI → Doctor → Raw Result → Formatter → Output
 
 module RailsForge
-  # Doctor class provides a full project health check
   class Doctor
-    # Initialize the Doctor analyzer
+    ANALYZER_MAP = {
+      controller:  ->(p) { Analyzers::ControllerAnalyzer.analyze(p) },
+      model:       ->(p) { Analyzers::ModelAnalyzer.analyze(p) },
+      database:    ->(p) { Analyzers::DatabaseAnalyzer.analyze(p) },
+      spec:        ->(p) { Analyzers::SpecAnalyzer.analyze(p) },
+      security:    ->(p) { Analyzers::SecurityAnalyzer.analyze(p) },
+      performance: ->(p) { Analyzers::PerformanceAnalyzer.analyze(p) },
+      refactor:    ->(p) { Analyzers::RefactorAnalyzer.analyze(p) }
+    }.freeze
+
+    SEVERITY_WEIGHTS = {
+      "critical" => 20,
+      "high"     => 10,
+      "medium"   =>  5,
+      "low"      =>  2,
+      "info"     =>  0
+    }.freeze
+
+    class DoctorError < StandardError; end
+
     def initialize(base_path = nil)
-      @base_path = base_path || find_rails_app_path
+      @base_path = base_path || Analyzers::BaseAnalyzer.find_rails_app_path
       raise DoctorError, "Not in a Rails application directory" unless @base_path
 
-      @results = {
-        controllers: [],
-        models: [],
-        database: [],
-        specs: [],
-        refactors: [],
-        metrics: {}
-      }
+      @issues  = []
+      @metrics = {}
+      @errors  = {}
     end
 
-    # Run all analyzers and generate report
-    # @return [Hash] Complete health check results
+    # Run all analyzers and return raw result.
+    #
+    # @return [Hash] { score: Integer, issues: Array<Issue>, metrics: Hash }
     def run
-      puts "Running RailsForge Doctor..."
-      puts ""
+      collect_issues
+      collect_metrics
 
-      # Run all analyzers
-      run_analyzers
-
-      # Calculate score
-      @results[:score] = calculate_score
-
-      # Print report
-      print_report
-
-      @results
+      {
+        score:   calculate_score,
+        issues:  @issues,
+        metrics: @metrics
+      }
     end
 
     private
 
-    # Run all available analyzers
-    def run_analyzers
-      # Controller analysis
-      begin
-        @results[:controllers] = RailsForge::Analyzers::RefactorAnalyzer.analyze_controllers(@base_path)
-      rescue => e
-        @results[:controllers] = []
-      end
-
-      # Model analysis
-      begin
-        @results[:models] = RailsForge::Analyzers::RefactorAnalyzer.analyze_models(@base_path)
-      rescue => e
-        @results[:models] = []
-      end
-
-      # Database analysis
-      begin
-        @results[:database] = RailsForge::Analyzers::DatabaseAnalyzer.analyze(@base_path)
-      rescue => e
-        @results[:database] = []
-      end
-
-      # Spec analysis
-      begin
-        @results[:specs] = RailsForge::Analyzers::SpecAnalyzer.analyze(@base_path)
-      rescue => e
-        @results[:specs] = []
-      end
-
-      # Refactor suggestions (from RefactorAnalyzer)
-      begin
-        @results[:refactors] = []
-        @results[:controllers].each do |ctrl|
-          @results[:refactors].concat(ctrl[:suggestions] || [])
-        end
-        @results[:models].each do |model|
-          @results[:refactors].concat(model[:suggestions] || [])
-        end
+    def collect_issues
+      ANALYZER_MAP.each do |name, callable|
+        results = callable.call(@base_path)
+        @issues.concat(Array(results))
       rescue => e
-        @results[:refactors] = []
+        @errors[name] = e.message
       end
+    end
 
-      # Metrics
-      begin
-        @results[:metrics] = RailsForge::Analyzers::MetricsAnalyzer.analyze(@base_path)
-      rescue => e
-        @results[:metrics] = {}
-      end
+    def collect_metrics
+      @metrics = Analyzers::MetricsAnalyzer.analyze(@base_path)
+    rescue
+      @metrics = {}
     end
 
-    # Calculate architecture score
-    # @return [Integer] Score out of 100
     def calculate_score
       score = 100
-
-      # Subtract 5 points per fat controller
-      fat_controllers = @results[:controllers].count { |c| c[:needs_refactoring] }
-      score -= fat_controllers * 5
-
-      # Subtract 5 points per fat model
-      fat_models = @results[:models].count { |m| m[:needs_refactoring] }
-      score -= fat_models * 5
-
-      # Subtract 3 points per missing spec
-      missing_specs = @results[:specs].count { |s| s[:has_spec] == false }
-      score -= missing_specs * 3
-
-      # Subtract 2 points per missing index (database issues)
-      missing_indexes = @results[:database].count { |d| d[:type] == :index }
-      score -= missing_indexes * 2
-
-      # Subtract 2 points per long method
-      long_methods = count_long_methods
-      score -= long_methods * 2
-
+      @issues.each { |issue| score -= SEVERITY_WEIGHTS.fetch(issue.severity.to_s, 0) }
       [score, 0].max
     end
-
-    # Count long methods in controllers and models
-    # @return [Integer] Number of long methods
-    def count_long_methods
-      count = 0
-
-      @results[:controllers].each do |ctrl|
-        methods = ctrl[:methods] || []
-        count += methods.count { |m| m[:lines].to_i > 15 }
-      end
-
-      @results[:models].each do |model|
-        methods = model[:methods] || []
-        count += methods.count { |m| m[:lines].to_i > 15 }
-      end
-
-      count
-    end
-
-    # Print formatted report
-    def print_report
-      score = @results[:score]
-      score_color = score >= 80 ? :green : score >= 50 ? :yellow : :red
-
-      puts "RailsForge Doctor Report"
-      puts "────────────────────────"
-      puts ""
-      puts "Architecture Score: #{colorize(score, score_color)}/100"
-      puts ""
-
-      # Controllers
-      puts "Controllers:"
-      if @results[:controllers].empty?
-        puts "  ✓ No issues found"
-      else
-        @results[:controllers].each do |ctrl|
-          issues = ctrl[:issues] || []
-          if issues.any?
-            puts "  ⚠ #{ctrl[:file]}: #{issues.join(', ')}"
-          end
-        end
-      end
-      puts ""
-
-      # Models
-      puts "Models:"
-      if @results[:models].empty?
-        puts "  ✓ No issues found"
-      else
-        @results[:models].each do |model|
-          issues = model[:issues] || []
-          if issues.any?
-            puts "  ⚠ #{model[:file]}: #{issues.join(', ')}"
-          end
-        end
-      end
-      puts ""
-
-      # Database
-      puts "Database:"
-      if @results[:database].empty?
-        puts "  ✓ No issues found"
-      else
-        @results[:database].first(5).each do |db|
-          puts "  ⚠ #{db[:table]}: #{db[:issue]}"
-        end
-        puts "  ... and #{@results[:database].count - 5} more" if @results[:database].count > 5
-      end
-      puts ""
-
-      # Specs
-      missing_specs = @results[:specs].select { |s| s[:has_spec] == false }
-      puts "Specs:"
-      if missing_specs.empty?
-        puts "  ✓ All components have specs"
-      else
-        puts "  ⚠ #{missing_specs.count} missing specs:"
-        missing_specs.first(5).each do |spec|
-          puts "    - #{spec[:type]}: #{spec[:name]}"
-        end
-        puts "    ... and #{missing_specs.count - 5} more" if missing_specs.count > 5
-      end
-      puts ""
-
-      # Suggestions
-      puts "Suggestions:"
-      if @results[:refactors].empty?
-        puts "  ✓ No refactoring suggestions"
-      else
-        @results[:refactors].first(10).each do |suggestion|
-          puts "  • #{suggestion}"
-        end
-        puts "  ... and #{@results[:refactors].count - 10} more" if @results[:refactors].count > 10
-      end
-      puts ""
-    end
-
-    # Find Rails app path
-    # @return [String, nil] Rails app root path
-    def find_rails_app_path
-      path = Dir.pwd
-      max_depth = 10
-
-      max_depth.times do
-        return path if File.exist?(File.join(path, "config", "application.rb"))
-        parent = File.dirname(path)
-        break if parent == path
-        path = parent
-      end
-
-      nil
-    end
-
-    # Colorize output for terminal
-    # @param text [String] Text to colorize
-    # @param color [Symbol] Color name
-    # @return [String] Colorized text
-    def colorize(text, color)
-      colors = {
-        green: "\e[32m",
-        yellow: "\e[33m",
-        red: "\e[31m",
-        reset: "\e[0m"
-      }
-      "#{colors[color]}#{text}#{colors[:reset]}"
-    end
-
-    # Error class for doctor issues
-    class DoctorError < StandardError; end
   end
 end

data/lib/railsforge/formatter.rb

@@ -0,0 +1,128 @@
+# Formatter — RailsForge v2 output renderer
+#
+# Responsibility: take raw results and produce human-readable or
+# machine-readable output. No analysis, no scoring, no side effects.
+#
+# Principle: Doctor decides what is true. Formatter decides how it looks.
+
+require "json"
+
+module RailsForge
+  module Formatter
+    SEVERITY_ORDER = %w[critical high medium low info].freeze
+
+    # Human-readable health report (from doctor).
+    #
+    # @param issues [Array<RailsForge::Issue>]
+    # @param score  [Integer] 0–100
+    # @return [String]
+    def self.render_text(issues, score)
+      lines       = []
+      score_color = score >= 80 ? :green : score >= 60 ? :yellow : :red
+
+      lines << "RailsForge Health Report"
+      lines << "─" * 50
+      lines << "Score:  #{colorize("#{score}/100", score_color)}"
+      lines << "Issues: #{issues.count} total"
+      lines << ""
+      lines.concat(render_issues(issues))
+      lines.join("\n")
+    end
+
+    # Human-readable diff report (from diff command).
+    # Shows only new issues; no score.
+    #
+    # @param new_issues [Array<RailsForge::Issue>]
+    # @return [String]
+    def self.render_diff(new_issues)
+      lines = []
+      lines << "RailsForge Diff"
+      lines << "─" * 50
+      lines << "New issues: #{new_issues.count}"
+      lines << ""
+      lines.concat(render_issues(new_issues))
+      lines.join("\n")
+    end
+
+    # Machine-readable JSON report.
+    #
+    # @param issues  [Array<RailsForge::Issue>]
+    # @param score   [Integer] 0–100
+    # @param metrics [Hash]
+    # @return [String] pretty-printed JSON
+    def self.render_json(issues, score, metrics = {})
+      counts = issues.group_by { |i| i.severity.to_s }.transform_values(&:count)
+
+      # All severity keys always present and in defined order, even if zero.
+      by_severity = SEVERITY_ORDER.each_with_object({}) { |sev, h| h[sev] = counts.fetch(sev, 0) }
+
+      output = {
+        score:   score,
+        issues:  issues.map(&:to_h),
+        summary: {
+          total:       issues.count,
+          by_severity: by_severity
+        },
+        metrics: metrics
+      }
+
+      JSON.pretty_generate(output)
+    end
+
+    # private helpers
+
+    # Renders severity-grouped issue list. Shared by render_text and render_diff.
+    #
+    # @param issues [Array<RailsForge::Issue>]
+    # @return [Array<String>] lines (no trailing newline join — caller decides)
+    def self.render_issues(issues)
+      lines      = []
+      grouped    = issues.group_by { |i| i.severity.to_s }
+      any_issues = false
+
+      SEVERITY_ORDER.each do |sev|
+        sev_issues = grouped[sev]
+        next unless sev_issues&.any?
+
+        any_issues = true
+        lines << colorize("#{sev.upcase} (#{sev_issues.count})", severity_color(sev))
+
+        sev_issues.group_by(&:analyzer).each do |analyzer, group|
+          lines << "  [#{analyzer}]"
+          group.each do |issue|
+            loc = issue.file ? "#{issue.file}#{issue.line ? ":#{issue.line}" : ""}" : nil
+            lines << "    #{[loc, issue.message].compact.join(" — ")}"
+            lines << "    → #{issue.suggestion}" if issue.suggestion
+          end
+        end
+        lines << ""
+      end
+
+      unless any_issues
+        lines << colorize("✓ No new issues", :green)
+        lines << ""
+      end
+
+      lines
+    end
+    private_class_method :render_issues
+
+    def self.colorize(text, color)
+      codes = { green: "\e[32m", yellow: "\e[33m", red: "\e[31m",
+                cyan: "\e[36m", magenta: "\e[35m", reset: "\e[0m" }
+      "#{codes[color]}#{text}#{codes[:reset]}"
+    end
+    private_class_method :colorize
+
+    def self.severity_color(sev)
+      case sev
+      when "critical" then :magenta
+      when "high"     then :red
+      when "medium"   then :yellow
+      when "low"      then :cyan
+      else                 :reset
+      end
+    end
+    private_class_method :severity_color
+  end
+end

data/lib/railsforge/issue.rb

@@ -0,0 +1,23 @@
+# Unified Issue model for RailsForge v2
+# All analyzers return Array<RailsForge::Issue>
+
+module RailsForge
+  Issue = Struct.new(:analyzer, :type, :severity, :file, :line, :message, :suggestion, keyword_init: true) do
+    def to_h
+      {
+        analyzer:   analyzer,
+        type:       type,
+        severity:   severity || "info",
+        file:       file,
+        line:       line,
+        message:    message,
+        suggestion: suggestion
+      }
+    end
+
+    def to_json(*)
+      require "json"
+      to_h.to_json
+    end
+  end
+end

data/lib/railsforge/loader.rb

@@ -1,60 +1,16 @@
-# RailsForge modular loader
-# This file centralizes all require statements with lazy loading
+# RailsForge loader
+# Loads only what is needed for the v2 doctor pipeline.
 
 require "fileutils"
 
-# Get the lib directory path
-LIB_DIR = File.dirname(__FILE__)
-
-# Core modules - always needed
 require_relative "version"
-
-# Minimal CLI loader for --help and --version (fast)
+require_relative "issue"
+require_relative "formatter"
 require_relative "cli_minimal"
 
-# Lazy-load everything else
 module RailsForge
   class << self
-    # Lazy-load generators
-    def require_generator(name)
-      require_relative "generators/#{name}"
-    end
-
-    # Lazy-load analyzers  
-    def require_analyzer(name)
-      require_relative "analyzers/#{name}"
-    end
-
-    # Lazy-load other modules
-    def require_module(name)
-      require_relative name
-    end
-
-    # Preload all (for commands that need everything)
     def preload_all!
-      require_relative "profiles"
-      require_relative "template_loader"
-      
-      # Define Generators module first to ensure proper namespace
-      require_relative "generators/base_generator"
-      
-      # Generators
-      require_relative "generators/service_generator"
-      require_relative "generators/job_generator"
-      require_relative "generators/query_generator"
-      require_relative "generators/form_generator"
-      require_relative "generators/presenter_generator"
-      require_relative "generators/policy_generator"
-      require_relative "generators/serializer_generator"
-      require_relative "generators/api_generator"
-      require_relative "generators/view_component_generator"
-      require_relative "generators/stimulus_controller_generator"
-      require_relative "generators/demo_generator"
-      require_relative "generators/devops_generator"
-      require_relative "generators/monitoring_generator"
-      require_relative "generators/test_generator"
-      
-      # Analyzers
       require_relative "analyzers/base_analyzer"
       require_relative "analyzers/controller_analyzer"
       require_relative "analyzers/model_analyzer"
@@ -64,23 +20,8 @@ module RailsForge
       require_relative "analyzers/refactor_analyzer"
       require_relative "analyzers/security_analyzer"
       require_relative "analyzers/performance_analyzer"
-      
-      # Refactors & plugins
-      require_relative "refactors/refactor_controller"
-      require_relative "plugins"
-      
-      # Legacy (modules with class methods)
-      require_relative "mailer_generator"
-      require_relative "feature_generator"
-      require_relative "audit"
       require_relative "doctor"
-      require_relative "graph"
-      require_relative "wizard"
-      require_relative "wizard_tui"
-      require_relative "config"
-      require_relative "generator"
-      
-      # CLI
+      require_relative "diff"
       require_relative "cli"
     end
   end