Fix doctor command false version mismatch for beta/prerelease versions (#2064)

## Summary

Fixes #2063 - The doctor command was incorrectly reporting version
mismatches for beta/alpha/rc versions even when gem and NPM package
versions were identical.

## Problem

When running `rake react_on_rails:doctor` with matching prerelease
versions:
- Gem: `16.2.0.beta.10`
- NPM: `16.2.0-beta.10`

The doctor would show a false warning:
```
⚠️  Version mismatch detected:
• Gem version: 16.2.0.beta.10
• NPM version: 16.2.0-beta.10
```

## Root Cause

The original code from PR #1787 used `gsub(/[^0-9.]/, "")` to strip all
non-numeric/non-dot characters:
- Input: `"16.2.0-beta.10"`
- Output: `"16.2.0.10"` (both dash AND "beta" removed)
- Compared with: `"16.2.0.beta.10"` (gem version)
- Result: Never matches! ❌

**Note:** CodeRabbit [caught this bug during the original PR
review](#1787 (review))
but the suggestion was not implemented.

## Solution

Use the existing `VersionSyntaxConverter.npm_to_rubygem` utility which
properly handles NPM-to-Ruby version format conversion:
- Removes version prefixes (`^`, `~`, `=`)
- Converts NPM semver format (`-beta`) to Ruby gem format (`.beta`)
- Already has comprehensive test coverage

## Changes

**File:** `lib/react_on_rails/system_checker.rb`

**Before:**
```ruby
clean_npm_version = npm_version.gsub(/[^0-9.]/, "")
```

**After:**
```ruby
converter = ReactOnRails::VersionSyntaxConverter.new
normalized_npm_version = converter.npm_to_rubygem(npm_version)
```

## Testing

Verified with test app using both gem and NPM at `16.2.0.beta.10`:

✅ **Matching versions:** No false warning
```
✅ React on Rails gem and NPM package versions match (16.2.0.beta.10)
```

✅ **Caret/tilde prefixes:** Handled correctly with appropriate warning
```
✅ React on Rails gem and NPM package versions match (16.2.0.beta.10)
⚠️  NPM package uses caret (^) version pattern
```

✅ **Real mismatches:** Still detected properly
```
⚠️  Version mismatch detected:
• Gem version: 16.2.0.beta.10
• NPM version: 16.2.0-beta.9
```

✅ **All prerelease formats:** Tested beta, alpha, rc, pre (16/16
scenarios pass)

## Benefits

- ✅ Fixes false warnings for all beta/alpha/rc/pre versions
- ✅ Uses existing, battle-tested utility (no code duplication)
- ✅ Already has test coverage (VersionSyntaxConverter specs)
- ✅ More accurate variable naming (`normalized_npm_version` vs
`clean_npm_version`)
- ✅ No breaking changes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Improved npm and gem version compatibility checking to accurately
handle prerelease and format variations, reducing false version mismatch
warnings.

* **Tests**
* Enhanced test coverage for version synchronization validation across
various version formats.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Claude <[email protected]>

Author: ihabadham

lib/react_on_rails/system_checker.rb

@@ -213,17 +213,20 @@ def check_package_version_sync # rubocop:disable Metrics/CyclomaticComplexity
 
         return unless npm_version && defined?(ReactOnRails::VERSION)
 
-        # Clean version strings for comparison (remove ^, ~, =, etc.)
-        clean_npm_version = npm_version.gsub(/[^0-9.]/, "")
+        # Normalize NPM version format to Ruby gem format for comparison
+        # Uses existing VersionSyntaxConverter to handle dash/dot differences
+        # (e.g., "16.2.0-beta.10" → "16.2.0.beta.10")
+        converter = ReactOnRails::VersionSyntaxConverter.new
+        normalized_npm_version = converter.npm_to_rubygem(npm_version)
         gem_version = ReactOnRails::VERSION
 
-        if clean_npm_version == gem_version
+        if normalized_npm_version == gem_version
           add_success("✅ React on Rails gem and NPM package versions match (#{gem_version})")
           check_version_patterns(npm_version, gem_version)
         else
           # Check for major version differences
           gem_major = gem_version.split(".")[0].to_i
-          npm_major = clean_npm_version.split(".")[0].to_i
+          npm_major = normalized_npm_version.split(".")[0].to_i
 
           if gem_major != npm_major # rubocop:disable Style/NegatedIfElseCondition
             add_error(<<~MSG.strip)

spec/lib/react_on_rails/system_checker_spec.rb

@@ -321,6 +321,165 @@
     end
   end
 
+  describe "#check_package_version_sync" do
+    before do
+      stub_const("ReactOnRails::VERSION", "16.2.0.beta.10")
+    end
+
+    context "when package.json does not exist" do
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(false)
+      end
+
+      it "does not add any messages" do
+        messages_count_before = checker.messages.count
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.count).to eq(messages_count_before)
+      end
+    end
+
+    context "when package.json exists with matching beta versions" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "16.2.0-beta.10" } }.to_json
+      end
+
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "adds a success message" do
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.any? do |msg|
+          msg[:type] == :success && msg[:content].include?("versions match")
+        end).to be true
+      end
+    end
+
+    context "when package.json has beta version with caret prefix" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "^16.2.0-beta.10" } }.to_json
+      end
+
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "adds a success message and version pattern warning" do
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.any? do |msg|
+          msg[:type] == :success && msg[:content].include?("versions match")
+        end).to be true
+        expect(checker.warnings?).to be true
+      end
+    end
+
+    context "when package.json has alpha version" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "16.2.0-alpha.5" } }.to_json
+      end
+
+      before do
+        stub_const("ReactOnRails::VERSION", "16.2.0.alpha.5")
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "correctly matches alpha versions" do
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.any? do |msg|
+          msg[:type] == :success && msg[:content].include?("versions match")
+        end).to be true
+      end
+    end
+
+    context "when package.json has rc version" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "16.2.0-rc.1" } }.to_json
+      end
+
+      before do
+        stub_const("ReactOnRails::VERSION", "16.2.0.rc.1")
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "correctly matches rc versions" do
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.any? do |msg|
+          msg[:type] == :success && msg[:content].include?("versions match")
+        end).to be true
+      end
+    end
+
+    context "when package.json has stable version" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "16.2.0" } }.to_json
+      end
+
+      before do
+        stub_const("ReactOnRails::VERSION", "16.2.0")
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "correctly matches stable versions" do
+        checker.send(:check_package_version_sync)
+        expect(checker.messages.any? do |msg|
+          msg[:type] == :success && msg[:content].include?("versions match")
+        end).to be true
+      end
+    end
+
+    context "when versions have minor mismatch" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "16.2.0-beta.9" } }.to_json
+      end
+
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "adds a warning message" do
+        checker.send(:check_package_version_sync)
+        expect(checker.warnings?).to be true
+        expect(checker.messages.last[:content]).to include("Version mismatch detected")
+      end
+    end
+
+    context "when versions have major mismatch" do
+      let(:package_json_content) do
+        { "dependencies" => { "react-on-rails" => "15.0.0" } }.to_json
+      end
+
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return(package_json_content)
+      end
+
+      it "adds an error message" do
+        checker.send(:check_package_version_sync)
+        expect(checker.errors?).to be true
+        expect(checker.messages.last[:content]).to include("Major version mismatch")
+      end
+    end
+
+    context "when package.json has invalid JSON" do
+      before do
+        allow(File).to receive(:exist?).with("package.json").and_return(true)
+        allow(File).to receive(:read).with("package.json").and_return("invalid json")
+      end
+
+      it "handles parsing errors gracefully" do
+        expect do
+          checker.send(:check_package_version_sync)
+        end.not_to raise_error
+      end
+    end
+  end
+
   describe "private methods" do
     describe "#cli_exists?" do
       it "returns true when command exists" do