stackharbinger 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9932e2c3197ac2e3a514ac213380f97c336f85c8c302745db6754f70f7c1a79
-  data.tar.gz: 11f4b85563611e4921eba0666f29181bb26560d19ddb65dd0673e331276dd7bd
+  metadata.gz: 0625ffb650537306abc4297407d0373c204c69412c7610254488c1006461bbcc
+  data.tar.gz: 65106dadaa487141d44e7772c57d9b0c59e18ab478517f0e94cad1440b8ab8b4
 SHA512:
-  metadata.gz: e0271ed33509bcf4fa3bce6a9f7b214753107131d3dfddbc248d68d5aea7cdb0b6a11eee4f4c2367f3060f1f1f7a7b81bca27b07e0f67a427c75eb0b0cd0efd5
-  data.tar.gz: 71178783539fdf85565e517bad7ebc983f188ff13bfa179d77d4fc6dcea953308c8c93ccb7fe22441ea8af51d00e4a437708a2769a345f04667e4de6768f16fb
+  metadata.gz: 3922e4f871e0782ebf821ef3e01f91aebba249c908f81a3b8f94e550d0d7d68a8525118d61f78b326b801aeecb801fbd89f975b48c2c95bbafd12c7703ebcf7a
+  data.tar.gz: c50866bca2f2b69d995d01735d62da1cb44f436aa546e5a069d7f8b50b8d25e63d95969f4df85ed008cd7d893a7e8d92959efe12e29e7834199f7322455a9cb9

data/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-01-18
+
+### Added
+- **PostgreSQL detection**: Detects PostgreSQL versions from Rails projects
+  - Checks `config/database.yml` for `adapter: postgresql`
+  - Runs `psql --version` for local databases
+  - Falls back to `pg` gem version from `Gemfile.lock`
+  - Skips shell commands for remote databases (AWS RDS, etc.) to avoid client vs server version mismatch
+- **MySQL detection**: Detects MySQL versions from Rails projects
+  - Supports both `mysql2` and `trilogy` adapters (Rails 7.1+)
+  - Runs `mysql --version` or `mysqld --version` for local databases
+  - Falls back to gem version from `Gemfile.lock`
+  - Smart remote database detection
+- **Rescan command**: `harbinger rescan` to bulk update all tracked projects
+  - Updates all projects with latest detected versions
+  - Automatically removes projects with missing directories
+  - `--verbose` flag for detailed output
+  - Progress counter shows scan status
+- **Enhanced dashboard**: PostgreSQL and MySQL columns in `harbinger show`
+  - Database versions displayed in table
+  - Database EOL dates included in status calculation
+  - Dashboard prioritizes database EOL issues
+- **Database EOL tracking**: Fetches EOL data for PostgreSQL and MySQL
+  - `harbinger update` now fetches database EOL data
+  - Supports major-only version cycles (PostgreSQL) and major.minor cycles (MySQL)
+- **Multi-database support**: Handles Rails 6+ multi-database configurations
+
+### Changed
+- `EolFetcher` now supports major-only version matching (PostgreSQL uses "16", not "16.11")
+- Scan output includes database versions with aligned formatting
+- Status calculation includes database EOL dates
+
+### Technical
+- Added `DatabaseDetector` abstract base class for database detection
+- Added `PostgresDetector` with local/remote detection (116 total tests passing)
+- Added `MysqlDetector` with trilogy and mysql2 support
+- Test fixtures for various database.yml configurations
+- Remote database detection to avoid shell command mismatches
+- Support for single and multi-database Rails configurations
+
 ## [0.2.0] - 2026-01-18
 
 ### Added

data/README.md

@@ -2,20 +2,30 @@
 
 **Track End-of-Life dates for your tech stack and stay ahead of deprecations.**
 
-Harbinger is a CLI tool that scans your Ruby and Rails projects, detects versions, and warns you about upcoming EOL (End-of-Life) dates. Never get caught off-guard by unsupported dependencies again.
+Harbinger is a CLI tool that scans your Ruby, Rails, PostgreSQL, and MySQL versions, and warns you about upcoming EOL (End-of-Life) dates. Never get caught off-guard by unsupported dependencies again.
 
 ## Features
 
-- 🔍 **Auto-detects versions** from `.ruby-version`, `Gemfile`, and `Gemfile.lock`
+- 🔍 **Auto-detects versions** from `.ruby-version`, `Gemfile`, `Gemfile.lock`, and `config/database.yml`
+- 🐘 **Database detection** for PostgreSQL and MySQL (mysql2/trilogy adapters)
 - 📅 **Fetches EOL data** from [endoflife.date](https://endoflife.date)
 - 🎨 **Color-coded warnings** (red: already EOL, yellow: <6 months, green: safe)
 - ⚡ **Smart caching** (24-hour cache, works offline after first fetch)
 - 📊 **Track multiple projects** with `--save` and view dashboard with `harbinger show`
-- 🔄 **Bulk scanning** with `--recursive` flag to scan entire directories
+- 🔄 **Bulk operations** with `--recursive` scan and `rescan` command
 - 🚀 **Zero configuration** - just run `harbinger scan`
 
 ## Installation
 
+### Homebrew (macOS)
+
+```bash
+brew tap RichD/harbinger
+brew install stackharbinger
+```
+
+### RubyGems
+
 ```bash
 gem install stackharbinger
 ```
@@ -26,7 +36,7 @@ Or add to your Gemfile:
 gem 'stackharbinger'
 ```
 
-The command is still `harbinger` (shorter to type).
+The command is `harbinger` (shorter to type).
 
 ## Usage
 
@@ -52,8 +62,9 @@ harbinger scan --path ~/Projects --recursive --save
 Scanning /Users/you/Projects/my-app...
 
 Detected versions:
-  Ruby:  3.2.0
-  Rails: 7.0.8
+  Ruby:       3.2.0
+  Rails:      7.0.8
+  PostgreSQL: 16.11
 
 Fetching EOL data...
 
@@ -64,6 +75,10 @@ Ruby 3.2.0:
 Rails 7.0.8:
   EOL Date: 2025-06-01
   Status:   ALREADY EOL (474 days ago)
+
+PostgreSQL 16.11:
+  EOL Date: 2028-11-09
+  Status:   1026 days remaining
 ```
 
 ### View tracked projects
@@ -78,14 +93,24 @@ harbinger show
 ```
 Tracked Projects (10)
 ================================================================================
-┌───────────────────┬───────┬──────────┬─────────────┐
-│ Project           │ Ruby  │ Rails    │ Status      │
-├───────────────────┼───────┼──────────┼─────────────┤
-│ ledger            │ 3.3.0 │ 6.1.7.10 │ ✗ Rails EOL │
-│ option_tracker    │ 3.3.0 │ 7.0.8.7  │ ✗ Rails EOL │
-│ CarCal            │ -     │ 8.0.2    │ ✓ Current   │
-│ job_tracker       │ 3.3.0 │ 8.0.4    │ ✓ Current   │
-└───────────────────┴───────┴──────────┴─────────────┘
+┌───────────────────┬───────┬──────────┬────────────┬───────┬─────────────┐
+│ Project           │ Ruby  │ Rails    │ PostgreSQL │ MySQL │ Status      │
+├───────────────────┼───────┼──────────┼────────────┼───────┼─────────────┤
+│ ledger            │ 3.3.0 │ 6.1.7.10 │ -          │ -     │ ✗ Rails EOL │
+│ option_tracker    │ 3.3.0 │ 7.0.8.7  │ -          │ -     │ ✗ Rails EOL │
+│ CarCal            │ -     │ 8.0.2    │ -          │ -     │ ✓ Current   │
+│ job_tracker       │ 3.3.0 │ 8.0.4    │ 16.11      │ -     │ ✓ Current   │
+└───────────────────┴───────┴──────────┴────────────┴───────┴─────────────┘
+```
+
+### Re-scan all tracked projects
+
+```bash
+# Update all tracked projects with latest versions
+harbinger rescan
+
+# Show detailed output for each project
+harbinger rescan --verbose
 ```
 
 ### Update EOL data
@@ -106,6 +131,8 @@ harbinger version
 1. **Detection**: Harbinger looks for version info in your project:
    - Ruby: `.ruby-version`, `Gemfile` (`ruby "x.x.x"`), `Gemfile.lock` (RUBY VERSION)
    - Rails: `Gemfile.lock` (rails gem)
+   - PostgreSQL: `config/database.yml` (adapter check) + `psql --version` or `pg` gem
+   - MySQL: `config/database.yml` (mysql2/trilogy adapter) + `mysql --version` or gem version
 
 2. **EOL Data**: Fetches official EOL dates from [endoflife.date](https://endoflife.date) API
 
@@ -130,6 +157,22 @@ Ruby:  Present (version not specified - add .ruby-version or ruby declaration in
 
 Parses `Gemfile.lock` for the rails gem version.
 
+### PostgreSQL Detection
+
+1. Checks `config/database.yml` for `adapter: postgresql`
+2. Tries `psql --version` for local databases (skips for remote hosts)
+3. Falls back to `pg` gem version from `Gemfile.lock`
+
+**Note**: For remote databases (AWS RDS, etc.), shows gem version since shell command would give local client version, not server version.
+
+### MySQL Detection
+
+1. Checks `config/database.yml` for `adapter: mysql2` or `adapter: trilogy`
+2. Tries `mysql --version` or `mysqld --version` for local databases
+3. Falls back to `mysql2` or `trilogy` gem version from `Gemfile.lock`
+
+**Supported adapters**: `mysql2` (traditional) and `trilogy` (Rails 7.1+)
+
 ## Requirements
 
 - Ruby >= 3.1.0
@@ -154,23 +197,24 @@ bundle exec exe/harbinger scan .
 
 ## Roadmap
 
-### V0.2.0 - Current
-- ✅ Dashboard: `harbinger show` to see all tracked projects
-- ✅ Config management: Save and track multiple projects with `--save`
-- ✅ Recursive scanning: `--recursive` flag to scan multiple projects at once
-- ✅ Enhanced project tracking with YAML config
+### V0.3.0 - Current
+- ✅ PostgreSQL version detection with local/remote database handling
+- ✅ MySQL version detection (mysql2 and trilogy adapters)
+- ✅ Rescan command to update all tracked projects
+- ✅ Enhanced dashboard with database columns
+- ✅ EOL tracking for PostgreSQL and MySQL
 
-### V0.3.0 - Planned
-- 🐘 PostgreSQL version detection
-- 🗄️ MySQL version detection
-- 🔄 Rescan command to update all tracked projects
+### V0.4.0 - Planned
 - 📋 Export reports to JSON/CSV
+- 🐳 Docker Compose database version detection
+- 🔴 Redis version detection
+- 🍃 MongoDB version detection
 
 ### V1.0 - Future
 - 🐍 Python support (pyproject.toml, requirements.txt)
 - 📦 Node.js support (package.json, .nvmrc)
 - 🦀 Rust support (Cargo.toml)
-- 🏠 Homebrew distribution: `brew install harbinger`
+- 🐘 Go support (go.mod)
 
 ### V2.0 - Vision
 - 🤖 AI-powered upgrade summaries

data/docs/index.html

@@ -21,7 +21,8 @@
 
             <div class="flex flex-col sm:flex-row gap-4">
                 <div class="bg-gray-900 rounded-lg p-4 font-mono text-sm">
-                    <span class="text-gray-400">$</span> <span class="text-green-400">gem install stackharbinger</span>
+                    <div class="mb-2"><span class="text-gray-400">$</span> <span class="text-green-400">brew tap RichD/harbinger</span></div>
+                    <div><span class="text-gray-400">$</span> <span class="text-green-400">brew install stackharbinger</span></div>
                 </div>
                 <a href="https://github.com/RichD/harbinger" class="inline-block bg-white text-blue-600 px-8 py-4 rounded-lg font-semibold hover:bg-blue-50 transition text-center">
                     View on GitHub →
@@ -59,10 +60,20 @@
                 <h3 class="text-xl font-semibold mb-2">Works Offline</h3>
                 <p class="text-gray-600">Smart caching means it works offline after initial data fetch</p>
             </div>
+            <div class="bg-white p-6 rounded-lg shadow-sm">
+                <div class="text-4xl mb-4">📊</div>
+                <h3 class="text-xl font-semibold mb-2">Dashboard View</h3>
+                <p class="text-gray-600">Track multiple projects and see EOL status at a glance with harbinger show</p>
+            </div>
+            <div class="bg-white p-6 rounded-lg shadow-sm">
+                <div class="text-4xl mb-4">🔄</div>
+                <h3 class="text-xl font-semibold mb-2">Bulk Scanning</h3>
+                <p class="text-gray-600">Recursively scan entire directories to find and track all your projects</p>
+            </div>
             <div class="bg-white p-6 rounded-lg shadow-sm">
                 <div class="text-4xl mb-4">🧪</div>
                 <h3 class="text-xl font-semibold mb-2">Well Tested</h3>
-                <p class="text-gray-600">36 RSpec tests with 100% pass rate, built with TDD</p>
+                <p class="text-gray-600">52 RSpec tests with 100% pass rate, built with TDD</p>
             </div>
         </div>
     </div>
@@ -73,7 +84,11 @@
             <h2 class="text-3xl font-bold mb-8">Quick Start</h2>
 
             <div class="bg-gray-900 rounded-lg p-6 mb-8 font-mono text-sm overflow-x-auto">
-                <div class="text-gray-400"># Install</div>
+                <div class="text-gray-400"># Install via Homebrew</div>
+                <div class="mb-1"><span class="text-gray-400">$</span> <span class="text-green-400">brew tap RichD/harbinger</span></div>
+                <div class="mb-4"><span class="text-gray-400">$</span> <span class="text-green-400">brew install stackharbinger</span></div>
+
+                <div class="text-gray-400"># Or via RubyGems</div>
                 <div class="mb-4"><span class="text-gray-400">$</span> <span class="text-green-400">gem install stackharbinger</span></div>
 
                 <div class="text-gray-400"># Scan your project</div>
@@ -96,7 +111,10 @@
             <div class="prose max-w-none">
                 <h3 class="text-2xl font-semibold mb-4">Commands</h3>
                 <ul class="space-y-3 text-gray-700">
-                    <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger scan [PATH]</code> - Scan a project and show EOL status</li>
+                    <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger scan --path [PATH]</code> - Scan a project and show EOL status</li>
+                    <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger scan --save</code> - Save project for tracking</li>
+                    <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger scan --recursive</code> - Scan all projects in a directory</li>
+                    <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger show</code> - View dashboard of all tracked projects</li>
                     <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger update</code> - Force refresh EOL data from API</li>
                     <li><code class="bg-gray-100 px-2 py-1 rounded">harbinger version</code> - Show harbinger version</li>
                 </ul>
@@ -109,21 +127,21 @@
         <h2 class="text-3xl font-bold mb-8 text-center">Roadmap</h2>
         <div class="grid md:grid-cols-3 gap-8">
             <div>
-                <h3 class="text-xl font-semibold mb-4 text-green-600">✅ V0.1.0 (Current)</h3>
+                <h3 class="text-xl font-semibold mb-4 text-green-600">✅ V0.2.0 (Current)</h3>
                 <ul class="space-y-2 text-gray-600">
-                    <li>• Ruby & Rails detection</li>
-                    <li>• EOL data fetching</li>
-                    <li>• CLI with color output</li>
-                    <li>• Smart caching</li>
+                    <li>• Dashboard view</li>
+                    <li>• Project tracking</li>
+                    <li>• Recursive scanning</li>
+                    <li>• Homebrew distribution</li>
                 </ul>
             </div>
             <div>
-                <h3 class="text-xl font-semibold mb-4 text-blue-600">📋 V0.2.0 (Planned)</h3>
+                <h3 class="text-xl font-semibold mb-4 text-blue-600">📋 V0.3.0 (Planned)</h3>
                 <ul class="space-y-2 text-gray-600">
-                    <li>• Dashboard view</li>
-                    <li>• Config management</li>
                     <li>• PostgreSQL detection</li>
                     <li>• MySQL detection</li>
+                    <li>• Rescan command</li>
+                    <li>• Export to JSON/CSV</li>
                 </ul>
             </div>
             <div>
@@ -131,8 +149,8 @@
                 <ul class="space-y-2 text-gray-600">
                     <li>• Python support</li>
                     <li>• Node.js support</li>
-                    <li>• Go & Rust support</li>
-                    <li>• Homebrew distribution</li>
+                    <li>• Go support</li>
+                    <li>• Rust support</li>
                 </ul>
             </div>
         </div>

data/lib/harbinger/analyzers/database_detector.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Harbinger
+  module Analyzers
+    # Abstract base class for database version detection in Rails projects
+    # Provides common functionality for detecting database versions from Rails projects
+    class DatabaseDetector
+      attr_reader :project_path
+
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      # Main detection method - returns version string or nil
+      def detect
+        return nil unless database_detected?
+
+        # Try shell command first (actual database version)
+        version = detect_from_shell
+        return version if version
+
+        # Fallback to gem version from Gemfile.lock
+        detect_from_gemfile_lock
+      end
+
+      # Check if database.yml indicates this database is used
+      def database_detected?
+        return false unless database_yml_exists?
+
+        config = parse_database_yml
+        return false unless config
+
+        # Check production or default section
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return false unless section
+
+        adapter = extract_adapter_from_section(section)
+        return false unless adapter
+
+        Array(adapter_name).any? { |name| adapter == name }
+      end
+
+      protected
+
+      # Extract adapter from database config section
+      # Handles both single-database and multi-database (Rails 6+) configurations
+      def extract_adapter_from_section(section)
+        # Single database: { "adapter" => "postgresql", ... }
+        return section["adapter"] if section["adapter"]
+
+        # Multi-database: { "primary" => { "adapter" => "postgresql", ... }, "cache" => { ... } }
+        # Check primary first, then fall back to first nested config
+        nested_config = section["primary"] || section.values.find { |v| v.is_a?(Hash) && v["adapter"] }
+        nested_config["adapter"] if nested_config
+      end
+
+      # Abstract method - must be implemented by subclasses
+      # Returns the adapter name(s) to look for in database.yml
+      def adapter_name
+        raise NotImplementedError, "Subclasses must implement adapter_name"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      # Detects version from shell command (e.g., psql --version)
+      def detect_from_shell
+        raise NotImplementedError, "Subclasses must implement detect_from_shell"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      # Detects version from Gemfile.lock gem version
+      def detect_from_gemfile_lock
+        raise NotImplementedError, "Subclasses must implement detect_from_gemfile_lock"
+      end
+
+      # Read and parse config/database.yml
+      def parse_database_yml
+        database_yml_path = File.join(project_path, "config", "database.yml")
+        return nil unless File.exist?(database_yml_path)
+
+        content = File.read(database_yml_path)
+        YAML.safe_load(content, aliases: true)
+      rescue Psych::SyntaxError, StandardError
+        nil
+      end
+
+      # Check if database.yml exists
+      def database_yml_exists?
+        File.exist?(File.join(project_path, "config", "database.yml"))
+      end
+
+      # Read and parse Gemfile.lock
+      def parse_gemfile_lock
+        gemfile_lock_path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(gemfile_lock_path)
+
+        File.read(gemfile_lock_path)
+      rescue StandardError
+        nil
+      end
+
+      # Extract gem version from Gemfile.lock content
+      def extract_gem_version(gemfile_lock_content, gem_name)
+        return nil unless gemfile_lock_content
+
+        # Match pattern like: "    pg (1.5.4)"
+        match = gemfile_lock_content.match(/^\s{4}#{Regexp.escape(gem_name)}\s+\(([^)]+)\)/)
+        match[1] if match
+      end
+
+      # Execute shell command safely
+      def execute_command(command)
+        output = `#{command} 2>&1`.strip
+        return nil unless $?.success?
+
+        output
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/mysql_detector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "database_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects MySQL version from Rails projects
+    # Supports both mysql2 and trilogy adapters
+    class MysqlDetector < DatabaseDetector
+      protected
+
+      def adapter_name
+        ["mysql2", "trilogy"]
+      end
+
+      def detect_from_shell
+        # Skip shell command if database is remote
+        return nil if remote_database?
+
+        # Try mysql command first, then mysqld
+        output = execute_command("mysql --version") || execute_command("mysqld --version")
+        return nil unless output
+
+        # Parse: "mysql  Ver 8.0.33" or "mysqld  Ver 8.0.33"
+        # Also handles MariaDB: "mysql  Ver 15.1 Distrib 10.11.2-MariaDB"
+        match = output.match(/Ver\s+(?:\d+\.\d+\s+Distrib\s+)?(\d+\.\d+\.\d+)/)
+        match[1] if match
+      end
+
+      def detect_from_gemfile_lock
+        content = parse_gemfile_lock
+        return nil unless content
+
+        # Check which adapter is being used
+        config = parse_database_yml
+        return nil unless config
+
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return nil unless section
+
+        adapter = extract_adapter_from_section(section)
+
+        # Return appropriate gem version based on adapter
+        if adapter == "trilogy"
+          version = extract_gem_version(content, "trilogy")
+          version ? "#{version} (trilogy gem)" : nil
+        else
+          version = extract_gem_version(content, "mysql2")
+          version ? "#{version} (mysql2 gem)" : nil
+        end
+      end
+
+      private
+
+      # Check if database configuration indicates a remote database
+      # (same logic as PostgresDetector)
+      def remote_database?
+        config = parse_database_yml
+        return false unless config
+
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return false unless section
+
+        db_config = if section["adapter"]
+                      section
+                    else
+                      section["primary"] || section.values.find { |v| v.is_a?(Hash) && v["adapter"] }
+                    end
+
+        return false unless db_config
+
+        host = db_config["host"]
+
+        # No host specified = localhost (Unix socket)
+        return false if host.nil? || host.empty?
+
+        # Explicit localhost indicators
+        local_hosts = ["localhost", "127.0.0.1", "::1", "0.0.0.0"]
+        !local_hosts.include?(host.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/postgres_detector.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "database_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects PostgreSQL version from Rails projects
+    class PostgresDetector < DatabaseDetector
+      protected
+
+      def adapter_name
+        "postgresql"
+      end
+
+      def detect_from_shell
+        # Skip shell command if database is remote
+        # (shell gives client version, not server version)
+        return nil if remote_database?
+
+        output = execute_command("psql --version")
+        return nil unless output
+
+        # Parse: "psql (PostgreSQL) 15.3" or "psql (PostgreSQL) 15.3 (Ubuntu 15.3-1)"
+        match = output.match(/PostgreSQL\)\s+(\d+\.\d+)/)
+        match[1] if match
+      end
+
+      def detect_from_gemfile_lock
+        content = parse_gemfile_lock
+        version = extract_gem_version(content, "pg")
+        version ? "#{version} (pg gem)" : nil
+      end
+
+      private
+
+      # Check if database configuration indicates a remote database
+      def remote_database?
+        config = parse_database_yml
+        return false unless config
+
+        # Get the section with database config
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return false unless section
+
+        # Handle multi-database config
+        db_config = if section["adapter"]
+                      section
+                    else
+                      section["primary"] || section.values.find { |v| v.is_a?(Hash) && v["adapter"] }
+                    end
+
+        return false unless db_config
+
+        host = db_config["host"]
+
+        # No host specified = localhost (Unix socket)
+        return false if host.nil? || host.empty?
+
+        # Explicit localhost indicators
+        local_hosts = ["localhost", "127.0.0.1", "::1", "0.0.0.0"]
+        !local_hosts.include?(host.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/harbinger/cli.rb

@@ -6,6 +6,9 @@ require "tty-table"
 require_relative "version"
 require "harbinger/analyzers/ruby_detector"
 require "harbinger/analyzers/rails_analyzer"
+require "harbinger/analyzers/database_detector"
+require "harbinger/analyzers/postgres_detector"
+require "harbinger/analyzers/mysql_detector"
 require "harbinger/eol_fetcher"
 require "harbinger/config_manager"
 
@@ -54,6 +57,8 @@ module Harbinger
       projects.each do |name, data|
         ruby_version = data["ruby"]
         rails_version = data["rails"]
+        postgres_version = data["postgres"]
+        mysql_version = data["mysql"]
 
         # Determine worst EOL status
         worst_status = :green
@@ -87,15 +92,45 @@ module Harbinger
           end
         end
 
+        if postgres_version && !postgres_version.empty? && !postgres_version.include?("gem")
+          postgres_eol = fetcher.eol_date_for("postgresql", postgres_version)
+          if postgres_eol
+            days = days_until(postgres_eol)
+            status = eol_color(days)
+            worst_status = status if status_priority(status) > status_priority(worst_status)
+            if days < 0
+              status_text = "✗ PostgreSQL EOL"
+            elsif days < 180 && !status_text.include?("EOL")
+              status_text = "⚠ PostgreSQL ending soon"
+            end
+          end
+        end
+
+        if mysql_version && !mysql_version.empty? && !mysql_version.include?("gem")
+          mysql_eol = fetcher.eol_date_for("mysql", mysql_version)
+          if mysql_eol
+            days = days_until(mysql_eol)
+            status = eol_color(days)
+            worst_status = status if status_priority(status) > status_priority(worst_status)
+            if days < 0
+              status_text = "✗ MySQL EOL"
+            elsif days < 180 && !status_text.include?("EOL")
+              status_text = "⚠ MySQL ending soon"
+            end
+          end
+        end
+
         ruby_display = ruby_version && !ruby_version.empty? ? ruby_version : "-"
         rails_display = rails_version && !rails_version.empty? ? rails_version : "-"
+        postgres_display = postgres_version && !postgres_version.empty? ? postgres_version : "-"
+        mysql_display = mysql_version && !mysql_version.empty? ? mysql_version : "-"
 
-        rows << [name, ruby_display, rails_display, colorize_status(status_text, worst_status)]
+        rows << [name, ruby_display, rails_display, postgres_display, mysql_display, colorize_status(status_text, worst_status)]
       end
 
       # Sort by status priority (worst first), then by name
       rows.sort_by! do |row|
-        status = row[3]
+        status = row[5] # Status is now in column 5 (0-indexed)
         priority = if status.include?("✗")
           0
         elsif status.include?("⚠")
@@ -107,7 +142,7 @@ module Harbinger
       end
 
       table = TTY::Table.new(
-        header: ["Project", "Ruby", "Rails", "Status"],
+        header: ["Project", "Ruby", "Rails", "PostgreSQL", "MySQL", "Status"],
         rows: rows
       )
 
@@ -121,7 +156,7 @@ module Harbinger
       say "Updating EOL data...", :cyan
 
       fetcher = EolFetcher.new
-      products = %w[ruby rails]
+      products = %w[ruby rails postgresql mysql]
 
       products.each do |product|
         say "Fetching #{product}...", :white
@@ -137,6 +172,68 @@ module Harbinger
       say "\nEOL data updated successfully!", :green
     end
 
+    desc "rescan", "Re-scan all tracked projects and update versions"
+    option :verbose, type: :boolean, aliases: "-v", desc: "Show detailed output for each project"
+    def rescan
+      config_manager = ConfigManager.new
+      projects = config_manager.list_projects
+
+      if projects.empty?
+        say "No projects tracked yet.", :yellow
+        say "Use 'harbinger scan --save' to add projects", :cyan
+        return
+      end
+
+      say "Re-scanning #{projects.size} tracked project(s)...\n\n", :cyan
+
+      updated_count = 0
+      removed_count = 0
+
+      projects.each_with_index do |(name, data), index|
+        project_path = data["path"]
+
+        unless File.directory?(project_path)
+          say "[#{index + 1}/#{projects.size}] #{name}: Path not found, removing from config", :yellow
+          config_manager.remove_project(name)
+          removed_count += 1
+          next
+        end
+
+        if options[:verbose]
+          say "=" * 60, :cyan
+          say "[#{index + 1}/#{projects.size}] Re-scanning #{name}", :cyan
+          say "=" * 60, :cyan
+          scan_single(project_path)
+        else
+          say "[#{index + 1}/#{projects.size}] #{name}...", :white
+
+          # Detect versions quietly
+          ruby_detector = Analyzers::RubyDetector.new(project_path)
+          rails_analyzer = Analyzers::RailsAnalyzer.new(project_path)
+          postgres_detector = Analyzers::PostgresDetector.new(project_path)
+          mysql_detector = Analyzers::MysqlDetector.new(project_path)
+
+          ruby_version = ruby_detector.detect
+          rails_version = rails_analyzer.detect
+          postgres_version = postgres_detector.detect
+          mysql_version = mysql_detector.detect
+
+          # Save to config
+          config_manager.save_project(
+            name: name,
+            path: project_path,
+            versions: { ruby: ruby_version, rails: rails_version, postgres: postgres_version, mysql: mysql_version }.compact
+          )
+        end
+
+        updated_count += 1
+      end
+
+      say "\n✓ Updated #{updated_count} project(s)", :green
+      say "✓ Removed #{removed_count} project(s) with missing directories", :yellow if removed_count > 0
+      say "\nView updated projects with: harbinger show", :cyan
+    end
+
     desc "version", "Show harbinger version"
     def version
       say "Harbinger version #{Harbinger::VERSION}", :cyan
@@ -179,33 +276,51 @@ module Harbinger
       # Detect versions
       ruby_detector = Analyzers::RubyDetector.new(project_path)
       rails_analyzer = Analyzers::RailsAnalyzer.new(project_path)
+      postgres_detector = Analyzers::PostgresDetector.new(project_path)
+      mysql_detector = Analyzers::MysqlDetector.new(project_path)
 
       ruby_version = ruby_detector.detect
       rails_version = rails_analyzer.detect
+      postgres_version = postgres_detector.detect
+      mysql_version = mysql_detector.detect
 
       ruby_present = ruby_detector.ruby_detected?
       rails_present = rails_analyzer.rails_detected?
+      postgres_present = postgres_detector.database_detected?
+      mysql_present = mysql_detector.database_detected?
 
       # Display results
       say "\nDetected versions:", :green
       if ruby_version
-        say "  Ruby:  #{ruby_version}", :white
+        say "  Ruby:       #{ruby_version}", :white
       elsif ruby_present
-        say "  Ruby:  Present (version not specified - add .ruby-version or ruby declaration in Gemfile)", :yellow
+        say "  Ruby:       Present (version not specified - add .ruby-version or ruby declaration in Gemfile)", :yellow
       else
-        say "  Ruby:  Not a Ruby project", :red
+        say "  Ruby:       Not a Ruby project", :red
       end
 
       if rails_version
-        say "  Rails: #{rails_version}", :white
+        say "  Rails:      #{rails_version}", :white
       elsif rails_present
-        say "  Rails: Present (version not found in Gemfile.lock)", :yellow
+        say "  Rails:      Present (version not found in Gemfile.lock)", :yellow
       else
-        say "  Rails: Not detected", :yellow
+        say "  Rails:      Not detected", :yellow
+      end
+
+      if postgres_version
+        say "  PostgreSQL: #{postgres_version}", :white
+      elsif postgres_present
+        say "  PostgreSQL: Present (version not detected)", :yellow
+      end
+
+      if mysql_version
+        say "  MySQL:      #{mysql_version}", :white
+      elsif mysql_present
+        say "  MySQL:      Present (version not detected)", :yellow
       end
 
       # Fetch and display EOL dates
-      if ruby_version || rails_version
+      if ruby_version || rails_version || postgres_version || mysql_version
         say "\nFetching EOL data...", :cyan
         fetcher = EolFetcher.new
 
@@ -216,11 +331,19 @@ module Harbinger
         if rails_version
           display_eol_info(fetcher, "Rails", rails_version)
         end
+
+        if postgres_version && !postgres_version.include?("gem")
+          display_eol_info(fetcher, "PostgreSQL", postgres_version)
+        end
+
+        if mysql_version && !mysql_version.include?("gem")
+          display_eol_info(fetcher, "MySQL", mysql_version)
+        end
       end
 
       # Save to config if --save flag is used
       if options[:save] && !options[:recursive]
-        save_to_config(project_path, ruby_version, rails_version)
+        save_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_version)
       elsif options[:save] && options[:recursive]
         # In recursive mode, save without the confirmation message for each project
         config_manager = ConfigManager.new
@@ -228,19 +351,19 @@ module Harbinger
         config_manager.save_project(
           name: project_name,
           path: project_path,
-          versions: { ruby: ruby_version, rails: rails_version }.compact
+          versions: { ruby: ruby_version, rails: rails_version, postgres: postgres_version, mysql: mysql_version }.compact
         )
       end
     end
 
-    def save_to_config(project_path, ruby_version, rails_version)
+    def save_to_config(project_path, ruby_version, rails_version, postgres_version = nil, mysql_version = nil)
       config_manager = ConfigManager.new
       project_name = File.basename(project_path)
 
       config_manager.save_project(
         name: project_name,
         path: project_path,
-        versions: { ruby: ruby_version, rails: rails_version }.compact
+        versions: { ruby: ruby_version, rails: rails_version, postgres: postgres_version, mysql: mysql_version }.compact
       )
 
       say "\n✓ Saved to config as '#{project_name}'", :green

data/lib/harbinger/eol_fetcher.rb

@@ -40,9 +40,14 @@ module Harbinger
       # Extract major.minor from version (e.g., "3.2.1" -> "3.2")
       version_parts = version.split(".")
       major_minor = "#{version_parts[0]}.#{version_parts[1]}"
+      major = version_parts[0]
 
-      # Find matching cycle
+      # Try major.minor first (e.g., "8.0" for MySQL, "3.2" for Ruby)
       entry = data.find { |item| item["cycle"] == major_minor }
+      return entry["eol"] if entry
+
+      # Fall back to major only (e.g., "16" for PostgreSQL)
+      entry = data.find { |item| item["cycle"] == major }
       entry ? entry["eol"] : nil
     end
 

data/lib/harbinger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Harbinger
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/harbinger.rb

@@ -4,6 +4,9 @@ require_relative "harbinger/version"
 require_relative "harbinger/cli"
 require_relative "harbinger/analyzers/ruby_detector"
 require_relative "harbinger/analyzers/rails_analyzer"
+require_relative "harbinger/analyzers/database_detector"
+require_relative "harbinger/analyzers/postgres_detector"
+require_relative "harbinger/analyzers/mysql_detector"
 require_relative "harbinger/eol_fetcher"
 
 module Harbinger

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stackharbinger
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rich Dabrowski
@@ -95,6 +95,9 @@ files:
 - docs/index.html
 - exe/harbinger
 - lib/harbinger.rb
+- lib/harbinger/analyzers/database_detector.rb
+- lib/harbinger/analyzers/mysql_detector.rb
+- lib/harbinger/analyzers/postgres_detector.rb
 - lib/harbinger/analyzers/rails_analyzer.rb
 - lib/harbinger/analyzers/ruby_detector.rb
 - lib/harbinger/cli.rb