stackharbinger 0.4.0 → 1.0.1

data/lib/harbinger/cli.rb

@@ -11,6 +11,10 @@ require "harbinger/analyzers/postgres_detector"
 require "harbinger/analyzers/mysql_detector"
 require "harbinger/analyzers/redis_detector"
 require "harbinger/analyzers/mongo_detector"
+require "harbinger/analyzers/python_detector"
+require "harbinger/analyzers/node_detector"
+require "harbinger/analyzers/rust_detector"
+require "harbinger/analyzers/go_detector"
 require "harbinger/eol_fetcher"
 require "harbinger/config_manager"
 require "harbinger/exporters/json_exporter"
@@ -22,6 +26,66 @@ module Harbinger
       true
     end
 
+    # Ecosystem priority for determining primary language
+    ECOSYSTEM_PRIORITY = %w[ruby python rust go nodejs].freeze
+
+    # Ecosystem definitions with languages and databases
+    ECOSYSTEMS = {
+      "ruby" => {
+        name: "Ruby Ecosystem",
+        languages: ["ruby", "rails"],
+        databases: ["postgres", "mysql", "redis", "mongo"]
+      },
+      "python" => {
+        name: "Python Ecosystem",
+        languages: ["python"],
+        databases: ["postgres", "mysql", "redis", "mongo"]
+      },
+      "rust" => {
+        name: "Rust Ecosystem",
+        languages: ["rust"],
+        databases: ["postgres", "mysql", "redis", "mongo"]
+      },
+      "go" => {
+        name: "Go Ecosystem",
+        languages: ["go"],
+        databases: ["postgres", "mysql", "redis", "mongo"]
+      },
+      "nodejs" => {
+        name: "Node.js Ecosystem",
+        languages: ["nodejs"],
+        databases: ["postgres", "mysql", "redis", "mongo"]
+      }
+    }.freeze
+
+    # Component display names for table headers
+    COMPONENT_DISPLAY_NAMES = {
+      "ruby" => "Ruby",
+      "rails" => "Rails",
+      "python" => "Python",
+      "nodejs" => "Node.js",
+      "rust" => "Rust",
+      "go" => "Go",
+      "postgres" => "PostgreSQL",
+      "mysql" => "MySQL",
+      "redis" => "Redis",
+      "mongo" => "MongoDB"
+    }.freeze
+
+    # Product name mapping for EOL API lookups
+    PRODUCT_NAME_MAP = {
+      "ruby" => "ruby",
+      "rails" => "rails",
+      "postgres" => "postgresql",
+      "mysql" => "mysql",
+      "redis" => "redis",
+      "mongo" => "mongodb",
+      "python" => "python",
+      "nodejs" => "nodejs",
+      "rust" => "rust",
+      "go" => "go"
+    }.freeze
+
     desc "scan", "Scan a project directory and detect versions"
     option :path, type: :string, aliases: "-p", desc: "Path to project directory (defaults to current directory)"
     option :save, type: :boolean, aliases: "-s", desc: "Save project to config for dashboard"
@@ -74,203 +138,34 @@ module Harbinger
         return
       end
 
+      # Group projects by ecosystem
       fetcher = EolFetcher.new
-      rows = []
-
-      # Track which columns have data
-      has_ruby = false
-      has_rails = false
-      has_postgres = false
-      has_mysql = false
-      has_redis = false
-      has_mongo = false
-
-      projects.each do |name, data|
-        ruby_version = data["ruby"]
-        rails_version = data["rails"]
-        postgres_version = data["postgres"]
-        mysql_version = data["mysql"]
-        redis_version = data["redis"]
-        mongo_version = data["mongo"]
-
-        # Filter out gem-only database versions
-        postgres_version = nil if postgres_version&.include?("gem")
-        mysql_version = nil if mysql_version&.include?("gem")
-        redis_version = nil if redis_version&.include?("gem")
-        mongo_version = nil if mongo_version&.include?("gem")
-
-        # Skip projects with no matching products
-        ruby_present = ruby_version && !ruby_version.empty?
-        rails_present = rails_version && !rails_version.empty?
-        postgres_present = postgres_version && !postgres_version.empty?
-        mysql_present = mysql_version && !mysql_version.empty?
-        redis_present = redis_version && !redis_version.empty?
-        mongo_present = mongo_version && !mongo_version.empty?
-
-        next unless ruby_present || rails_present || postgres_present || mysql_present || redis_present || mongo_present
-
-        # Track which columns have data
-        has_ruby ||= ruby_present
-        has_rails ||= rails_present
-        has_postgres ||= postgres_present
-        has_mysql ||= mysql_present
-        has_redis ||= redis_present
-        has_mongo ||= mongo_present
-
-        # Determine worst EOL status
-        worst_status = :green
-        status_text = "✓ Current"
-
-        if ruby_present
-          ruby_eol = fetcher.eol_date_for("ruby", ruby_version)
-          if ruby_eol
-            days = days_until(ruby_eol)
-            status = eol_color(days)
-            worst_status = status if status_priority(status) > status_priority(worst_status)
-            if days.negative?
-              status_text = "✗ Ruby EOL"
-            elsif days < 180
-              status_text = "⚠ Ruby ending soon"
-            end
-          end
-        end
-
-        if rails_present
-          rails_eol = fetcher.eol_date_for("rails", rails_version)
-          if rails_eol
-            days = days_until(rails_eol)
-            status = eol_color(days)
-            worst_status = status if status_priority(status) > status_priority(worst_status)
-            if days.negative?
-              status_text = "✗ Rails EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ Rails ending soon"
-            end
-          end
-        end
+      ecosystem_projects = group_projects_by_ecosystem(projects)
 
-        if postgres_present
-          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.negative?
-              status_text = "✗ PostgreSQL EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ PostgreSQL ending soon"
-            end
-          end
-        end
-
-        if mysql_present
-          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.negative?
-              status_text = "✗ MySQL EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ MySQL ending soon"
-            end
-          end
-        end
-
-        if redis_present
-          redis_eol = fetcher.eol_date_for("redis", redis_version)
-          if redis_eol
-            days = days_until(redis_eol)
-            status = eol_color(days)
-            worst_status = status if status_priority(status) > status_priority(worst_status)
-            if days.negative?
-              status_text = "✗ Redis EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ Redis ending soon"
-            end
-          end
-        end
-
-        if mongo_present
-          mongo_eol = fetcher.eol_date_for("mongodb", mongo_version)
-          if mongo_eol
-            days = days_until(mongo_eol)
-            status = eol_color(days)
-            worst_status = status if status_priority(status) > status_priority(worst_status)
-            if days.negative?
-              status_text = "✗ MongoDB EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ MongoDB ending soon"
-            end
-          end
-        end
-
-        rows << {
-          name: name,
-          path: File.dirname(data["path"] || ""),
-          ruby: ruby_present ? ruby_version : "-",
-          rails: rails_present ? rails_version : "-",
-          postgres: postgres_present ? postgres_version : "-",
-          mysql: mysql_present ? mysql_version : "-",
-          redis: redis_present ? redis_version : "-",
-          mongo: mongo_present ? mongo_version : "-",
-          status: colorize_status(status_text, worst_status),
-          status_raw: status_text
-        }
-      end
-
-      if rows.empty?
+      # Check if any projects have a programming language
+      if ecosystem_projects.empty?
         say "No projects with detected versions.", :yellow
         say "Use 'harbinger scan --save' to add projects", :cyan
         return
       end
 
-      say "Tracked Projects (#{rows.size})", :cyan
-      say "=" * 80, :cyan
-
-      # Sort by status priority (worst first), then by name
-      rows.sort_by! do |row|
-        priority = if row[:status_raw].include?("✗")
-                     0
-                   elsif row[:status_raw].include?("⚠")
-                     1
-                   else
-                     2
-                   end
-        [priority, row[:name]]
-      end
+      # Display header with total project count
+      total_projects = ecosystem_projects.values.sum(&:size)
+      say "Tracked Projects (#{total_projects})", :cyan
 
-      # Build dynamic headers and rows
-      headers = ["Project"]
-      headers << "Path" if options[:verbose]
-      headers << "Ruby" if has_ruby
-      headers << "Rails" if has_rails
-      headers << "PostgreSQL" if has_postgres
-      headers << "MySQL" if has_mysql
-      headers << "Redis" if has_redis
-      headers << "MongoDB" if has_mongo
-      headers << "Status"
+      # Render each ecosystem table
+      ECOSYSTEMS.keys.each do |ecosystem_key|
+        projects_in_ecosystem = ecosystem_projects[ecosystem_key]
+        next if projects_in_ecosystem.empty? # Hide empty tables
 
-      table_rows = rows.map do |row|
-        table_row = [row[:name]]
-        table_row << row[:path] if options[:verbose]
-        table_row << row[:ruby] if has_ruby
-        table_row << row[:rails] if has_rails
-        table_row << row[:postgres] if has_postgres
-        table_row << row[:mysql] if has_mysql
-        table_row << row[:redis] if has_redis
-        table_row << row[:mongo] if has_mongo
-        table_row << row[:status]
-        table_row
+        render_ecosystem_table(
+          ecosystem_key,
+          projects_in_ecosystem,
+          fetcher,
+          verbose: options[:verbose]
+        )
       end
 
-      table = TTY::Table.new(
-        header: headers,
-        rows: table_rows
-      )
-
-      puts table.render(:unicode, padding: [0, 1], resize: false)
-
       say "\nUse 'harbinger scan --path <project>' to update a project", :cyan
     end
 
@@ -279,7 +174,7 @@ module Harbinger
       say "Updating EOL data...", :cyan
 
       fetcher = EolFetcher.new
-      products = %w[ruby rails postgresql mysql redis mongodb]
+      products = %w[ruby rails postgresql mysql redis mongodb python nodejs rust go]
 
       products.each do |product|
         say "Fetching #{product}...", :white
@@ -352,6 +247,10 @@ module Harbinger
           mysql_detector = Analyzers::MysqlDetector.new(project_path)
           redis_detector = Analyzers::RedisDetector.new(project_path)
           mongo_detector = Analyzers::MongoDetector.new(project_path)
+          python_detector = Analyzers::PythonDetector.new(project_path)
+          node_detector = Analyzers::NodeDetector.new(project_path)
+          rust_detector = Analyzers::RustDetector.new(project_path)
+          go_detector = Analyzers::GoDetector.new(project_path)
 
           ruby_version = ruby_detector.detect
           rails_version = rails_analyzer.detect
@@ -359,13 +258,27 @@ module Harbinger
           mysql_version = mysql_detector.detect
           redis_version = redis_detector.detect
           mongo_version = mongo_detector.detect
+          python_version = python_detector.detect
+          nodejs_version = node_detector.detect
+          rust_version = rust_detector.detect
+          go_version = go_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, redis: redis_version, mongo: mongo_version }.compact
+            versions: {
+              ruby: ruby_version,
+              rails: rails_version,
+              postgres: postgres_version,
+              mysql: mysql_version,
+              redis: redis_version,
+              mongo: mongo_version,
+              python: python_version,
+              nodejs: nodejs_version,
+              rust: rust_version,
+              go: go_version
+            }.compact
           )
         end
 
@@ -384,6 +297,184 @@ module Harbinger
 
     private
 
+    # Calculate EOL status for a single component (e.g., ruby, rails, postgres)
+    # Returns: { status: :red/:yellow/:green, text: "✗ Ruby EOL", days: -30 } or nil
+    def calculate_component_status(component, version, fetcher)
+      return nil unless version && !version.empty?
+
+      product_name = PRODUCT_NAME_MAP[component]
+      eol_date = fetcher.eol_date_for(product_name, version)
+      return nil if eol_date.nil?
+
+      # Handle actively supported versions (eol = false)
+      if eol_date == false
+        component_display = COMPONENT_DISPLAY_NAMES[component] || component.capitalize
+        return { status: :green, text: "✓ Current", days: Float::INFINITY }
+      end
+
+      days = days_until(eol_date)
+      status = eol_color(days)
+
+      component_display = COMPONENT_DISPLAY_NAMES[component] || component.capitalize
+
+      text = if days.negative?
+               "✗ #{component_display} EOL"
+             elsif days < 180
+               "⚠ #{component_display} ending soon"
+             else
+               "✓ Current"
+             end
+
+      { status: status, text: text, days: days }
+    end
+
+    # Determine overall status for a project across specified components
+    # Returns: { status: :red/:yellow/:green, text: "✗ Ruby EOL" }
+    def determine_overall_status(project_data, components, fetcher)
+      worst_status = :green
+      status_text = "✓ Current"
+
+      components.each do |component|
+        version = project_data[component]
+        next unless version && !version.empty?
+
+        # Filter out gem-only database versions
+        if %w[postgres mysql redis mongo].include?(component) && version&.include?("gem")
+          next
+        end
+
+        component_status = calculate_component_status(component, version, fetcher)
+        next unless component_status
+
+        if status_priority(component_status[:status]) > status_priority(worst_status)
+          worst_status = component_status[:status]
+          status_text = component_status[:text]
+        end
+      end
+
+      { status: worst_status, text: status_text }
+    end
+
+    # Build a row hash for a single project with all its component versions
+    # Returns: { name: "project", path: "/path", ruby: "3.2.0", ..., status: colored_text }
+    def build_project_row(name, data, components, fetcher, verbose: false)
+      row = { name: name }
+      row[:path] = File.dirname(data["path"] || "") if verbose
+
+      # Add component versions
+      components.each do |component|
+        version = data[component]
+        # Filter out gem-only database versions
+        if %w[postgres mysql redis mongo].include?(component) && version&.include?("gem")
+          version = nil
+        end
+        row[component.to_sym] = (version && !version.empty?) ? version : "-"
+      end
+
+      # Calculate overall status
+      status_info = determine_overall_status(data, components, fetcher)
+      row[:status] = colorize_status(status_info[:text], status_info[:status])
+      row[:status_raw] = status_info[:text]
+
+      row
+    end
+
+    # Determine the primary ecosystem for a project based on detected languages
+    # Returns: "ruby", "python", "rust", "go", "nodejs", or nil
+    def determine_primary_ecosystem(data)
+      ECOSYSTEM_PRIORITY.each do |lang|
+        version = data[lang]
+        return lang if version && !version.empty?
+      end
+      nil # No language detected
+    end
+
+    # Group projects by their primary ecosystem
+    # Returns: { "ruby" => [[name, data], ...], "python" => [[name, data], ...] }
+    def group_projects_by_ecosystem(projects)
+      ecosystem_projects = Hash.new { |h, k| h[k] = [] }
+
+      projects.each do |name, data|
+        primary = determine_primary_ecosystem(data)
+
+        # Skip projects with no programming language detected
+        next unless primary
+
+        ecosystem_projects[primary] << [name, data]
+      end
+
+      ecosystem_projects
+    end
+
+    # Render a table for a single ecosystem with its projects
+    def render_ecosystem_table(ecosystem_key, projects, fetcher, verbose: false)
+      config = ECOSYSTEMS[ecosystem_key]
+      components = config[:languages] + config[:databases]
+
+      # Track which columns have data in this ecosystem
+      has_columns = Hash.new(false)
+      rows = []
+
+      projects.each do |name, data|
+        row = build_project_row(name, data, components, fetcher, verbose: verbose)
+
+        # Track columns with data
+        components.each do |component|
+          has_columns[component] = true if row[component.to_sym] != "-"
+        end
+
+        rows << row
+      end
+
+      return if rows.empty? # Skip empty ecosystems
+
+      # Sort by status priority (worst first)
+      rows.sort_by! do |row|
+        priority = if row[:status_raw].include?("✗")
+                     0
+                   elsif row[:status_raw].include?("⚠")
+                     1
+                   else
+                     2
+                   end
+        [priority, row[:name]]
+      end
+
+      # Build dynamic headers
+      headers = ["Project"]
+      headers << "Path" if verbose
+
+      components.each do |component|
+        next unless has_columns[component]
+
+        headers << COMPONENT_DISPLAY_NAMES[component]
+      end
+
+      headers << "Status"
+
+      # Build table rows matching headers
+      table_rows = rows.map do |row|
+        table_row = [row[:name]]
+        table_row << row[:path] if verbose
+
+        components.each do |component|
+          next unless has_columns[component]
+
+          table_row << row[component.to_sym]
+        end
+
+        table_row << row[:status]
+        table_row
+      end
+
+      # Render the table
+      say "\n#{config[:name]} (#{rows.size})", :cyan
+      say "=" * 80, :cyan
+
+      table = TTY::Table.new(header: headers, rows: table_rows)
+      puts table.render(:unicode, padding: [0, 1], resize: false)
+    end
+
     def scan_recursive(base_path)
       say "Scanning #{base_path} recursively for Ruby projects...", :cyan
 
@@ -433,6 +524,10 @@ module Harbinger
       mysql_detector = Analyzers::MysqlDetector.new(project_path)
       redis_detector = Analyzers::RedisDetector.new(project_path)
       mongo_detector = Analyzers::MongoDetector.new(project_path)
+      python_detector = Analyzers::PythonDetector.new(project_path)
+      node_detector = Analyzers::NodeDetector.new(project_path)
+      rust_detector = Analyzers::RustDetector.new(project_path)
+      go_detector = Analyzers::GoDetector.new(project_path)
 
       ruby_version = ruby_detector.detect
       rails_version = rails_analyzer.detect
@@ -440,80 +535,101 @@ module Harbinger
       mysql_version = mysql_detector.detect
       redis_version = redis_detector.detect
       mongo_version = mongo_detector.detect
+      python_version = python_detector.detect
+      nodejs_version = node_detector.detect
+      rust_version = rust_detector.detect
+      go_version = go_detector.detect
+
+      # Prepare data for ecosystem detection
+      data = {
+        "ruby" => ruby_version,
+        "rails" => rails_version,
+        "postgres" => postgres_version,
+        "mysql" => mysql_version,
+        "redis" => redis_version,
+        "mongo" => mongo_version,
+        "python" => python_version,
+        "nodejs" => nodejs_version,
+        "rust" => rust_version,
+        "go" => go_version
+      }
+
+      # Determine primary ecosystem
+      primary_ecosystem = determine_primary_ecosystem(data)
+
+      if primary_ecosystem.nil?
+        say "\nNo programming language detected", :yellow
+        say "This appears to be a database-only or infrastructure project", :yellow
+        return
+      end
 
-      ruby_present = ruby_detector.ruby_detected?
-      rails_present = rails_analyzer.rails_detected?
-      postgres_present = postgres_detector.database_detected?
-      mysql_present = mysql_detector.database_detected?
-      redis_present = redis_detector.redis_detected?
-      mongo_present = mongo_detector.mongo_detected?
+      # Get components to display for this ecosystem
+      config = ECOSYSTEMS[primary_ecosystem]
+      components_to_display = config[:languages] + config[:databases]
 
       # Display results
       say "\nDetected versions:", :green
-      if ruby_version
-        say "  Ruby:       #{ruby_version}", :white
-      elsif ruby_present
-        say "  Ruby:       Present (version not specified - add .ruby-version or ruby declaration in Gemfile)", :yellow
-      else
-        say "  Ruby:       Not a Ruby project", :red
-      end
-
-      if rails_version
-        say "  Rails:      #{rails_version}", :white
-      elsif rails_present
-        say "  Rails:      Present (version not found in Gemfile.lock)", :yellow
-      else
-        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
+      components_to_display.each do |component|
+        version = data[component]
+        display_name = COMPONENT_DISPLAY_NAMES[component]
+        detector_present = case component
+                           when "ruby" then ruby_detector.ruby_detected?
+                           when "rails" then rails_analyzer.rails_detected?
+                           when "postgres" then postgres_detector.database_detected?
+                           when "mysql" then mysql_detector.database_detected?
+                           when "redis" then redis_detector.redis_detected?
+                           when "mongo" then mongo_detector.mongo_detected?
+                           when "python" then python_detector.python_detected?
+                           when "nodejs" then node_detector.nodejs_detected?
+                           when "rust" then rust_detector.rust_detected?
+                           when "go" then go_detector.go_detected?
+                           else false
+                           end
+
+        if version && !version.empty?
+          say "  #{display_name.ljust(12)} #{version}", :white
+        elsif detector_present
+          say "  #{display_name.ljust(12)} Present (version not detected)", :yellow
+        end
       end
 
-      if redis_version
-        say "  Redis:      #{redis_version}", :white
-      elsif redis_present
-        say "  Redis:      Present (version not detected)", :yellow
-      end
+      # Fetch and display EOL dates
+      versions_to_check = components_to_display.filter_map do |component|
+        version = data[component]
+        next unless version && !version.empty?
+        # Filter out gem-only database versions
+        next if %w[postgres mysql redis mongo].include?(component) && version.include?("gem")
 
-      if mongo_version
-        say "  MongoDB:    #{mongo_version}", :white
-      elsif mongo_present
-        say "  MongoDB:    Present (version not detected)", :yellow
+        [component, version]
       end
 
-      # Fetch and display EOL dates
-      if ruby_version || rails_version || postgres_version || mysql_version || redis_version || mongo_version
+      if versions_to_check.any?
         say "\nFetching EOL data...", :cyan
         fetcher = EolFetcher.new
 
-        display_eol_info(fetcher, "Ruby", ruby_version) if ruby_version
-
-        display_eol_info(fetcher, "Rails", rails_version) if rails_version
-
-        if postgres_version && !postgres_version.include?("gem")
-          display_eol_info(fetcher, "PostgreSQL", postgres_version)
+        versions_to_check.each do |component, version|
+          display_name = COMPONENT_DISPLAY_NAMES[component]
+          display_eol_info(fetcher, display_name, version)
         end
-
-        display_eol_info(fetcher, "MySQL", mysql_version) if mysql_version && !mysql_version.include?("gem")
-
-        display_eol_info(fetcher, "Redis", redis_version) if redis_version && !redis_version.include?("gem")
-
-        display_eol_info(fetcher, "MongoDB", mongo_version) if mongo_version && !mongo_version.include?("gem")
       end
 
       # Save to config if --save flag is used
+      versions = {
+        ruby: ruby_version,
+        rails: rails_version,
+        postgres: postgres_version,
+        mysql: mysql_version,
+        redis: redis_version,
+        mongo: mongo_version,
+        python: python_version,
+        nodejs: nodejs_version,
+        rust: rust_version,
+        go: go_version
+      }.compact
+
       if options[:save] && !options[:recursive]
-        save_project_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_version,
-                               redis_version, mongo_version)
+        save_project_to_config(project_path, versions)
       elsif options[:save] && options[:recursive]
         # In recursive mode, save without the confirmation message for each project
         config_manager = ConfigManager.new
@@ -521,22 +637,19 @@ module Harbinger
         config_manager.save_project(
           name: project_name,
           path: project_path,
-          versions: { ruby: ruby_version, rails: rails_version, postgres: postgres_version,
-                      mysql: mysql_version, redis: redis_version, mongo: mongo_version }.compact
+          versions: versions
         )
       end
     end
 
-    def save_project_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_version,
-                               redis_version, mongo_version)
+    def save_project_to_config(project_path, versions)
       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, postgres: postgres_version,
-                    mysql: mysql_version, redis: redis_version, mongo: mongo_version }.compact
+        versions: versions
       )
 
       say "\n✓ Saved to config as '#{project_name}'", :green
@@ -544,19 +657,30 @@ module Harbinger
     end
 
     def display_eol_info(fetcher, product, version)
-      product_key = product.downcase
+      # Map display name to EOL API key
+      product_key = case product.downcase
+                    when "node.js" then "nodejs"
+                    when "postgresql" then "postgresql"
+                    when "mongodb" then "mongodb"
+                    else product.downcase
+                    end
+
       eol_date = fetcher.eol_date_for(product_key, version)
 
-      if eol_date
+      if eol_date.nil?
+        say "\n#{product} #{version}:", :white
+        say "  EOL Date: Unknown (version not found in database)", :yellow
+      elsif eol_date == false
+        say "\n#{product} #{version}:", :white
+        say "  EOL Date: N/A (currently supported)", :green
+        say "  Status:   Active support", :green
+      else
         days_until_eol = days_until(eol_date)
         color = eol_color(days_until_eol)
 
         say "\n#{product} #{version}:", :white
         say "  EOL Date: #{eol_date}", color
         say "  Status:   #{eol_status(days_until_eol)}", color
-      else
-        say "\n#{product} #{version}:", :white
-        say "  EOL Date: Unknown (version not found in database)", :yellow
       end
     end