stackharbinger 0.2.0 → 0.4.0

data/lib/harbinger/cli.rb

@@ -6,8 +6,15 @@ 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/analyzers/redis_detector"
+require "harbinger/analyzers/mongo_detector"
 require "harbinger/eol_fetcher"
 require "harbinger/config_manager"
+require "harbinger/exporters/json_exporter"
+require "harbinger/exporters/csv_exporter"
 
 module Harbinger
   class CLI < Thor
@@ -20,7 +27,7 @@ module Harbinger
     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
@@ -34,8 +41,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
 
@@ -45,27 +55,79 @@ module Harbinger
         return
       end
 
-      say "Tracked Projects (#{projects.size})", :cyan
-      say "=" * 80, :cyan
+      # 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 projects.empty?
+          say "No projects matching '#{project_filter}'", :yellow
+          return
+        end
+      end
+
+      # Handle export formats
+      if options[:format] != "table"
+        export_data(projects, options[:format], options[:output])
+        return
+      end
 
       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_version && !ruby_version.empty?
+        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 < 0
+            if days.negative?
               status_text = "✗ Ruby EOL"
             elsif days < 180
               status_text = "⚠ Ruby ending soon"
@@ -73,13 +135,13 @@ module Harbinger
           end
         end
 
-        if rails_version && !rails_version.empty?
+        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 < 0
+            if days.negative?
               status_text = "✗ Rails EOL"
             elsif days < 180 && !status_text.include?("EOL")
               status_text = "⚠ Rails ending soon"
@@ -87,31 +149,127 @@ module Harbinger
           end
         end
 
-        ruby_display = ruby_version && !ruby_version.empty? ? ruby_version : "-"
-        rails_display = rails_version && !rails_version.empty? ? rails_version : "-"
+        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
 
-        rows << [name, ruby_display, rails_display, colorize_status(status_text, worst_status)]
+      if rows.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|
-        status = row[3]
-        priority = if status.include?("✗")
-          0
-        elsif status.include?("⚠")
-          1
-        else
-          2
-        end
-        [priority, row[0]]
+        priority = if row[:status_raw].include?("✗")
+                     0
+                   elsif row[:status_raw].include?("⚠")
+                     1
+                   else
+                     2
+                   end
+        [priority, row[:name]]
+      end
+
+      # 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"
+
+      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
       end
 
       table = TTY::Table.new(
-        header: ["Project", "Ruby", "Rails", "Status"],
-        rows: rows
+        header: headers,
+        rows: table_rows
       )
 
-      puts table.render(:unicode, padding: [0, 1])
+      puts table.render(:unicode, padding: [0, 1], resize: false)
 
       say "\nUse 'harbinger scan --path <project>' to update a project", :cyan
     end
@@ -121,7 +279,7 @@ module Harbinger
       say "Updating EOL data...", :cyan
 
       fetcher = EolFetcher.new
-      products = %w[ruby rails]
+      products = %w[ruby rails postgresql mysql redis mongodb]
 
       products.each do |product|
         say "Fetching #{product}...", :white
@@ -137,6 +295,88 @@ 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
+      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)
+          redis_detector = Analyzers::RedisDetector.new(project_path)
+          mongo_detector = Analyzers::MongoDetector.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
+
+          # 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
+          )
+        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.positive?
+      say "\nView updated projects with: harbinger show", :cyan
+    end
+
     desc "version", "Show harbinger version"
     def version
       say "Harbinger version #{Harbinger::VERSION}", :cyan
@@ -147,9 +387,19 @@ module Harbinger
     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?
@@ -167,10 +417,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)
@@ -179,48 +429,91 @@ 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)
+      redis_detector = Analyzers::RedisDetector.new(project_path)
+      mongo_detector = Analyzers::MongoDetector.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
 
       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?
 
       # 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
+
+      if redis_version
+        say "  Redis:      #{redis_version}", :white
+      elsif redis_present
+        say "  Redis:      Present (version not detected)", :yellow
+      end
+
+      if mongo_version
+        say "  MongoDB:    #{mongo_version}", :white
+      elsif mongo_present
+        say "  MongoDB:    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 || redis_version || mongo_version
         say "\nFetching EOL data...", :cyan
         fetcher = EolFetcher.new
 
-        if ruby_version
-          display_eol_info(fetcher, "Ruby", ruby_version)
-        end
+        display_eol_info(fetcher, "Ruby", ruby_version) if ruby_version
+
+        display_eol_info(fetcher, "Rails", rails_version) if rails_version
 
-        if rails_version
-          display_eol_info(fetcher, "Rails", rails_version)
+        if postgres_version && !postgres_version.include?("gem")
+          display_eol_info(fetcher, "PostgreSQL", postgres_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
       if options[:save] && !options[:recursive]
-        save_to_config(project_path, ruby_version, rails_version)
+        save_project_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_version,
+                               redis_version, mongo_version)
       elsif options[:save] && options[:recursive]
         # In recursive mode, save without the confirmation message for each project
         config_manager = ConfigManager.new
@@ -228,19 +521,22 @@ 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, redis: redis_version, mongo: mongo_version }.compact
         )
       end
     end
 
-    def save_to_config(project_path, ruby_version, rails_version)
+    def save_project_to_config(project_path, ruby_version, rails_version, postgres_version, mysql_version,
+                               redis_version, mongo_version)
       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, redis: redis_version, mongo: mongo_version }.compact
       )
 
       say "\n✓ Saved to config as '#{project_name}'", :green
@@ -270,7 +566,7 @@ module Harbinger
     end
 
     def eol_color(days)
-      if days < 0
+      if days.negative?
         :red
       elsif days < 180 # < 6 months
         :yellow
@@ -280,7 +576,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)"
@@ -314,5 +610,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

data/lib/harbinger/eol_fetcher.rb

@@ -18,16 +18,14 @@ module Harbinger
       cache_file = cache_file_path(product)
 
       # Return fresh cache if available
-      if cache_fresh?(cache_file)
-        return read_cache(cache_file)
-      end
+      return read_cache(cache_file) if cache_fresh?(cache_file)
 
       # Try to fetch from API
       begin
         data = fetch_from_api(product)
         write_cache(cache_file, data)
         data
-      rescue StandardError => e
+      rescue StandardError
         # Fall back to stale cache if API fails
         read_cache(cache_file) if File.exist?(cache_file)
       end
@@ -39,11 +37,27 @@ 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]
+      major_minor = version_parts[1] ? "#{major}.#{version_parts[1]}" : nil
+
+      # Try exact major.minor first (e.g., "8.0" for MySQL, "3.2" for Ruby)
+      if major_minor
+        entry = data.find { |item| item["cycle"] == major_minor }
+        return entry["eol"] if entry
+      end
+
+      # Try major only (e.g., "16" for PostgreSQL)
+      entry = data.find { |item| item["cycle"] == major }
+      return entry["eol"] if entry
+
+      # For major-only versions, find the latest minor version in that major series
+      # (e.g., version "7" should match "7.4" which is the latest 7.x)
+      matching_entries = data.select { |item| item["cycle"].to_s.start_with?("#{major}.") }
+      return nil if matching_entries.empty?
 
-      # Find matching cycle
-      entry = data.find { |item| item["cycle"] == major_minor }
-      entry ? entry["eol"] : nil
+      # Sort by cycle version and get the latest (highest minor version)
+      latest = matching_entries.max_by { |item| item["cycle"].to_s.split(".").map(&:to_i) }
+      latest ? latest["eol"] : nil
     end
 
     private