stackharbinger 0.3.0 → 1.0.0

data/lib/harbinger/cli.rb

@@ -9,8 +9,16 @@ require "harbinger/analyzers/rails_analyzer"
 require "harbinger/analyzers/database_detector"
 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"
+require "harbinger/exporters/csv_exporter"
 
 module Harbinger
   class CLI < Thor
@@ -18,12 +26,71 @@ 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"
+    }.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"
     option :recursive, type: :boolean, aliases: "-r", desc: "Recursively scan all subdirectories with Gemfiles"
     def scan
-      project_path = options[:path] || Dir.pwd
+      project_path = File.expand_path(options[:path] || Dir.pwd)
 
       unless File.directory?(project_path)
         say "Error: #{project_path} is not a valid directory", :red
@@ -37,8 +104,11 @@ module Harbinger
       end
     end
 
-    desc "show", "Show EOL status for tracked projects"
-    def show
+    desc "show [PROJECT]", "Show EOL status for tracked projects"
+    option :verbose, type: :boolean, aliases: "-v", desc: "Show project paths"
+    option :format, type: :string, enum: %w[table json csv], default: "table", desc: "Output format (table, json, csv)"
+    option :output, type: :string, aliases: "-o", desc: "Output file path"
+    def show(project_filter = nil)
       config_manager = ConfigManager.new
       projects = config_manager.list_projects
 
@@ -48,105 +118,52 @@ module Harbinger
         return
       end
 
-      say "Tracked Projects (#{projects.size})", :cyan
-      say "=" * 80, :cyan
-
-      fetcher = EolFetcher.new
-      rows = []
-
-      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
-        status_text = "✓ Current"
-
-        if ruby_version && !ruby_version.empty?
-          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 < 0
-              status_text = "✗ Ruby EOL"
-            elsif days < 180
-              status_text = "⚠ Ruby ending soon"
-            end
-          end
+      # Filter by project name or path if specified
+      if project_filter
+        projects = projects.select do |name, data|
+          name.downcase.include?(project_filter.downcase) ||
+            data["path"]&.downcase&.include?(project_filter.downcase)
         end
 
-        if rails_version && !rails_version.empty?
-          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 < 0
-              status_text = "✗ Rails EOL"
-            elsif days < 180 && !status_text.include?("EOL")
-              status_text = "⚠ Rails ending soon"
-            end
-          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
+        if projects.empty?
+          say "No projects matching '#{project_filter}'", :yellow
+          return
         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
+      # Handle export formats
+      if options[:format] != "table"
+        export_data(projects, options[:format], options[:output])
+        return
+      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 : "-"
+      # Group projects by ecosystem
+      fetcher = EolFetcher.new
+      ecosystem_projects = group_projects_by_ecosystem(projects)
 
-        rows << [name, ruby_display, rails_display, postgres_display, mysql_display, colorize_status(status_text, worst_status)]
+      # 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
 
-      # Sort by status priority (worst first), then by name
-      rows.sort_by! do |row|
-        status = row[5] # Status is now in column 5 (0-indexed)
-        priority = if status.include?("✗")
-          0
-        elsif status.include?("⚠")
-          1
-        else
-          2
-        end
-        [priority, row[0]]
-      end
+      # Display header with total project count
+      total_projects = ecosystem_projects.values.sum(&:size)
+      say "Tracked Projects (#{total_projects})", :cyan
 
-      table = TTY::Table.new(
-        header: ["Project", "Ruby", "Rails", "PostgreSQL", "MySQL", "Status"],
-        rows: rows
-      )
+      # 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
 
-      puts table.render(:unicode, padding: [0, 1])
+        render_ecosystem_table(
+          ecosystem_key,
+          projects_in_ecosystem,
+          fetcher,
+          verbose: options[:verbose]
+        )
+      end
 
       say "\nUse 'harbinger scan --path <project>' to update a project", :cyan
     end
@@ -156,7 +173,7 @@ module Harbinger
       say "Updating EOL data...", :cyan
 
       fetcher = EolFetcher.new
-      products = %w[ruby rails postgresql mysql]
+      products = %w[ruby rails postgresql mysql redis mongodb python nodejs rust go]
 
       products.each do |product|
         say "Fetching #{product}...", :white
@@ -172,6 +189,21 @@ module Harbinger
       say "\nEOL data updated successfully!", :green
     end
 
+    desc "remove PROJECT", "Remove a project from tracking"
+    def remove(project_name)
+      config_manager = ConfigManager.new
+      project = config_manager.get_project(project_name)
+
+      if project
+        config_manager.remove_project(project_name)
+        say "Removed '#{project_name}' (#{project["path"]})", :green
+      else
+        say "Project '#{project_name}' not found", :yellow
+        say "\nTracked projects:", :cyan
+        config_manager.list_projects.keys.sort.each { |name| say "  #{name}" }
+      end
+    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
@@ -212,17 +244,40 @@ module Harbinger
           rails_analyzer = Analyzers::RailsAnalyzer.new(project_path)
           postgres_detector = Analyzers::PostgresDetector.new(project_path)
           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
           postgres_version = postgres_detector.detect
           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 }.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
 
@@ -230,7 +285,7 @@ module Harbinger
       end
 
       say "\n✓ Updated #{updated_count} project(s)", :green
-      say "✓ Removed #{removed_count} project(s) with missing directories", :yellow if removed_count > 0
+      say "✓ Removed #{removed_count} project(s) with missing directories", :yellow if removed_count.positive?
       say "\nView updated projects with: harbinger show", :cyan
     end
 
@@ -241,12 +296,194 @@ 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 unless eol_date
+
+      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
 
-      # Find all directories with Gemfiles
+      # Find all directories with Gemfiles, excluding common non-project directories
+      excluded_patterns = %w[
+        vendor/
+        node_modules/
+        tmp/
+        .git/
+        spec/fixtures/
+        test/fixtures/
+      ]
+
       gemfile_dirs = Dir.glob(File.join(base_path, "**/Gemfile"))
                         .map { |f| File.dirname(f) }
+                        .reject { |dir| excluded_patterns.any? { |pattern| dir.include?("/#{pattern}") } }
                         .sort
 
       if gemfile_dirs.empty?
@@ -264,10 +501,10 @@ module Harbinger
         say "\n" unless index == gemfile_dirs.length - 1
       end
 
-      if options[:save]
-        say "\n✓ Saved #{gemfile_dirs.length} project(s) to config", :green
-        say "View all tracked projects with: harbinger show", :cyan
-      end
+      return unless options[:save]
+
+      say "\n✓ Saved #{gemfile_dirs.length} project(s) to config", :green
+      say "View all tracked projects with: harbinger show", :cyan
     end
 
     def scan_single(project_path)
@@ -278,72 +515,114 @@ module Harbinger
       rails_analyzer = Analyzers::RailsAnalyzer.new(project_path)
       postgres_detector = Analyzers::PostgresDetector.new(project_path)
       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
       postgres_version = postgres_detector.detect
       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?
+      # 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
+      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 postgres_version
-        say "  PostgreSQL: #{postgres_version}", :white
-      elsif postgres_present
-        say "  PostgreSQL: 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 mysql_version
-        say "  MySQL:      #{mysql_version}", :white
-      elsif mysql_present
-        say "  MySQL:      Present (version not detected)", :yellow
+        [component, version]
       end
 
-      # Fetch and display EOL dates
-      if ruby_version || rails_version || postgres_version || mysql_version
+      if versions_to_check.any?
         say "\nFetching EOL data...", :cyan
         fetcher = EolFetcher.new
 
-        if ruby_version
-          display_eol_info(fetcher, "Ruby", ruby_version)
-        end
-
-        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)
+        versions_to_check.each do |component, version|
+          display_name = COMPONENT_DISPLAY_NAMES[component]
+          display_eol_info(fetcher, display_name, version)
         end
       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_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_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
@@ -351,19 +630,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 }.compact
+          versions: versions
         )
       end
     end
 
-    def save_to_config(project_path, ruby_version, rails_version, postgres_version = nil, mysql_version = nil)
+    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 }.compact
+        versions: versions
       )
 
       say "\n✓ Saved to config as '#{project_name}'", :green
@@ -371,7 +650,14 @@ 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
@@ -393,7 +679,7 @@ module Harbinger
     end
 
     def eol_color(days)
-      if days < 0
+      if days.negative?
         :red
       elsif days < 180 # < 6 months
         :yellow
@@ -403,7 +689,7 @@ module Harbinger
     end
 
     def eol_status(days)
-      if days < 0
+      if days.negative?
         "ALREADY EOL (#{days.abs} days ago)"
       elsif days < 30
         "ENDING SOON (#{days} days remaining)"
@@ -437,5 +723,23 @@ module Harbinger
         text
       end
     end
+
+    def export_data(projects, format, output_path)
+      exporter = case format
+                 when "json"
+                   Exporters::JsonExporter.new(projects)
+                 when "csv"
+                   Exporters::CsvExporter.new(projects)
+                 end
+
+      result = exporter.export
+
+      if output_path
+        File.write(output_path, result)
+        say "Exported to #{output_path}", :green
+      else
+        puts result
+      end
+    end
   end
 end