railsforge 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c8f6efda41c0957fd4a4675fbd5e310fb825c2a26001c4e5af5abb02af97347
-  data.tar.gz: 91f9e9baf1d073a0bbe8cd7db41972504183281bc27945aaee77185f02229718
+  metadata.gz: b004345e61120afc6f11432c72baeddb6981aee6e504d50b5eedf5b0334f71d6
+  data.tar.gz: 51bae87bc37e99da845f89ea3e9af014a2d9b6d85128417223978e5ffef14958
 SHA512:
-  metadata.gz: bb84ad0cbdbdd3b154c3e4b4dbeb6acbe909f5d67fa8511b2002dccd18756436531e33d508e247335a5ed2603fc5b6654b84136cc2c73d1e75bd3308e797e6f4
-  data.tar.gz: 2705a473ed8ae7323f5800c75e7a5ecb0a077ff07beef6707e830c409d24737a02ce2310241b421127f2ff9cb64bbd583096599a2291c6762246c2077f29bfaf
+  metadata.gz: 1bc07580544ae7d06679dd03986cf6268b7598ead40a495a54ff8b2f8d0da1730871d01738ec419455998992f85cbda3619dbd60ccf77fb6ea73cce53ce7179c
+  data.tar.gz: 7b1b7c639d4da0968d6db7ea4e2a9d98a28398186f93ffeaddab9ee86c60c9481296d72ab64c0c9d552e795f635de3d146664e7cc6415d9c919db16bfe68aa18

data/README.md

@@ -107,19 +107,60 @@ Returns structured output for CI pipelines and automated tooling:
   "summary": {
     "total": 9,
     "by_severity": {
+      "critical": 0,
       "high": 2,
       "medium": 4,
-      "low": 3
+      "low": 3,
+      "info": 0
     }
   }
 }
 ```
 
-**Fail a CI build when score drops below threshold:**
+All five severity keys are always present, even when zero. Score is always an integer. Output is deterministic.
+
+---
+
+## CI Usage
+
+RailsForge provides signal. CI decides consequences.
 
 ```bash
-score=$(railsforge doctor --format=json | jq '.score')
-[ "$score" -ge 70 ] || exit 1
+railsforge doctor --format=json | jq '.score'
+```
+
+RailsForge always exits `0` on a successful run. Your CI script owns the pass/fail logic.
+
+### GitHub Actions
+
+```yaml
+name: RailsForge Health Check
+
+on: [push, pull_request]
+
+jobs:
+  railsforge:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: Install RailsForge
+        run: gem install railsforge
+
+      - name: Run RailsForge
+        run: |
+          score=$(railsforge doctor --format=json | jq '.score')
+          echo "Score: $score"
+          if [ "$score" -lt 80 ]; then
+            echo "RailsForge score below threshold"
+            exit 1
+          fi
 ```
 
 ---
@@ -134,14 +175,6 @@ score=$(railsforge doctor --format=json | jq '.score')
 
 ---
 
-## What RailsForge Is Not
-
-RailsForge is not a generator, scaffolding system, or DevOps platform.
-
-It does not create architecture. It diagnoses existing architecture.
-
----
-
 ## Installation
 
 ```bash

data/lib/railsforge/cli.rb

@@ -1,5 +1,5 @@
 # CLI — RailsForge v2 command dispatcher
-# Supported commands: doctor
+# Supported commands: doctor, diff
 
 module RailsForge
   class CLI
@@ -9,6 +9,8 @@ module RailsForge
       case command
       when "doctor"
         handle_doctor_command(args)
+      when "diff"
+        handle_diff_command(args)
       when "--version", "-v"
         puts "RailsForge #{VERSION}"
       when nil, "--help", "-h"
@@ -25,10 +27,11 @@ module RailsForge
         RailsForge — Rails application health diagnostics
 
         Usage:
-          railsforge doctor                Run full diagnostic scan
-          railsforge doctor --format=json  Output as JSON
-          railsforge --version             Show version
-          railsforge --help                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
 
@@ -45,5 +48,21 @@ module RailsForge
       puts "Error: #{e.message}"
       exit 1
     end
+
+    def self.handle_diff_command(args)
+      baseline_path = args[0]
+      current_path  = args[1]
+
+      unless baseline_path && current_path
+        puts "Usage: railsforge diff <baseline.json> <current.json>"
+        exit 1
+      end
+
+      new_issues = RailsForge::Diff.run(baseline_path, current_path)
+      puts RailsForge::Formatter.render_diff(new_issues)
+    rescue RailsForge::Diff::DiffError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
   end
 end

data/lib/railsforge/cli_minimal.rb

@@ -25,6 +25,7 @@ module RailsForge
         require_relative "analyzers/security_analyzer"
         require_relative "analyzers/performance_analyzer"
         require_relative "doctor"
+        require_relative "diff"
         require_relative "cli"
 
         CLI.start([command] + args)
@@ -36,10 +37,11 @@ module RailsForge
         RailsForge — Rails application health diagnostics
 
         Usage:
-          railsforge doctor                Run full diagnostic scan
-          railsforge doctor --format=json  Output as JSON
-          railsforge --version             Show version
-          railsforge --help                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/formatter.rb

@@ -1,6 +1,6 @@
 # Formatter — RailsForge v2 output renderer
 #
-# Responsibility: take raw Doctor results and produce human-readable or
+# 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.
@@ -11,7 +11,7 @@ module RailsForge
   module Formatter
     SEVERITY_ORDER = %w[critical high medium low info].freeze
 
-    # Human-readable text report
+    # Human-readable health report (from doctor).
     #
     # @param issues [Array<RailsForge::Issue>]
     # @param score  [Integer] 0–100
@@ -25,7 +25,58 @@ module RailsForge
       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
 
@@ -48,38 +99,13 @@ module RailsForge
       end
 
       unless any_issues
-        lines << colorize("✓ No issues found", :green)
+        lines << colorize("✓ No new issues", :green)
         lines << ""
       end
 
-      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 = {})
-      by_severity = issues
-                      .group_by { |i| i.severity.to_s }
-                      .transform_values(&:count)
-
-      output = {
-        score:   score,
-        issues:  issues.map(&:to_h),
-        summary: {
-          total:       issues.count,
-          by_severity: by_severity
-        },
-        metrics: metrics
-      }
-
-      JSON.pretty_generate(output)
+      lines
     end
-
-    # private helpers
+    private_class_method :render_issues
 
     def self.colorize(text, color)
       codes = { green: "\e[32m", yellow: "\e[33m", red: "\e[31m",

data/lib/railsforge/loader.rb

@@ -21,6 +21,7 @@ module RailsForge
       require_relative "analyzers/security_analyzer"
       require_relative "analyzers/performance_analyzer"
       require_relative "doctor"
+      require_relative "diff"
       require_relative "cli"
     end
   end

data/lib/railsforge/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railsforge
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - RailsForge Contributors
@@ -92,6 +92,7 @@ files:
 - lib/railsforge/analyzers/spec_analyzer.rb
 - lib/railsforge/cli.rb
 - lib/railsforge/cli_minimal.rb
+- lib/railsforge/diff.rb
 - lib/railsforge/doctor.rb
 - lib/railsforge/formatter.rb
 - lib/railsforge/issue.rb