stackharbinger 0.3.0 → 0.4.0

data/lib/harbinger/cli.rb

@@ -9,8 +9,12 @@ 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
@@ -23,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
@@ -37,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
 
@@ -48,29 +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"
@@ -78,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"
@@ -92,13 +149,13 @@ module Harbinger
           end
         end
 
-        if postgres_version && !postgres_version.empty? && !postgres_version.include?("gem")
+        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 < 0
+            if days.negative?
               status_text = "✗ PostgreSQL EOL"
             elsif days < 180 && !status_text.include?("EOL")
               status_text = "⚠ PostgreSQL ending soon"
@@ -106,13 +163,13 @@ module Harbinger
           end
         end
 
-        if mysql_version && !mysql_version.empty? && !mysql_version.include?("gem")
+        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 < 0
+            if days.negative?
               status_text = "✗ MySQL EOL"
             elsif days < 180 && !status_text.include?("EOL")
               status_text = "⚠ MySQL ending soon"
@@ -120,33 +177,99 @@ module Harbinger
           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 : "-"
+        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
 
-        rows << [name, ruby_display, rails_display, postgres_display, mysql_display, colorize_status(status_text, worst_status)]
+        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?
+        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[5] # Status is now in column 5 (0-indexed)
-        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", "PostgreSQL", "MySQL", "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
@@ -156,7 +279,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]
 
       products.each do |product|
         say "Fetching #{product}...", :white
@@ -172,6 +295,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 +350,22 @@ 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)
 
           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 }.compact
+            versions: { ruby: ruby_version, rails: rails_version, postgres: postgres_version,
+                        mysql: mysql_version, redis: redis_version, mongo: mongo_version }.compact
           )
         end
 
@@ -230,7 +373,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
 
@@ -244,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?
@@ -264,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)
@@ -278,16 +431,22 @@ 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)
 
       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
@@ -319,31 +478,42 @@ module Harbinger
         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 || postgres_version || mysql_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
 
-        if rails_version
-          display_eol_info(fetcher, "Rails", rails_version)
-        end
+        display_eol_info(fetcher, "Rails", rails_version) if rails_version
 
         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
+        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, postgres_version, mysql_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
@@ -351,19 +521,22 @@ 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: { 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, postgres_version = nil, mysql_version = nil)
+    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, 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 }.compact
       )
 
       say "\n✓ Saved to config as '#{project_name}'", :green
@@ -393,7 +566,7 @@ module Harbinger
     end
 
     def eol_color(days)
-      if days < 0
+      if days.negative?
         :red
       elsif days < 180 # < 6 months
         :yellow
@@ -403,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)"
@@ -437,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,16 +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 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
+      # 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
 
-      # Fall back to major only (e.g., "16" for PostgreSQL)
+      # Try major only (e.g., "16" for PostgreSQL)
       entry = data.find { |item| item["cycle"] == major }
-      entry ? entry["eol"] : nil
+      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?
+
+      # 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

data/lib/harbinger/exporters/base_exporter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "date"
+require "harbinger/eol_fetcher"
+
+module Harbinger
+  module Exporters
+    # Base class for exporters that transform project data into various formats
+    class BaseExporter
+      COMPONENTS = %w[ruby rails postgres mysql redis mongo].freeze
+      PRODUCT_NAMES = {
+        "ruby" => "ruby",
+        "rails" => "rails",
+        "postgres" => "postgresql",
+        "mysql" => "mysql",
+        "redis" => "redis",
+        "mongo" => "mongodb"
+      }.freeze
+
+      def initialize(projects, fetcher: nil)
+        @projects = projects
+        @fetcher = fetcher || EolFetcher.new
+      end
+
+      def export
+        raise NotImplementedError, "Subclasses must implement #export"
+      end
+
+      protected
+
+      def build_export_data
+        @projects.filter_map do |name, data|
+          components = build_components(data)
+          next if components.empty?
+
+          {
+            name: name,
+            path: data["path"],
+            components: components,
+            overall_status: determine_overall_status(components)
+          }
+        end
+      end
+
+      private
+
+      def build_components(data)
+        COMPONENTS.filter_map do |component|
+          version = data[component]
+          next if version.nil? || version.empty?
+          next if version.include?("gem")
+
+          product = PRODUCT_NAMES[component]
+          eol_date = @fetcher.eol_date_for(product, version)
+          days = eol_date ? days_until(eol_date) : nil
+          status = days ? calculate_status(days) : "unknown"
+
+          {
+            name: component,
+            version: version,
+            eol_date: eol_date,
+            days_remaining: days,
+            status: status
+          }
+        end
+      end
+
+      def calculate_status(days)
+        if days.negative?
+          "eol"
+        elsif days < 180
+          "warning"
+        else
+          "safe"
+        end
+      end
+
+      def determine_overall_status(components)
+        statuses = components.map { |c| c[:status] }
+        return "unknown" if statuses.empty? || statuses.all? { |s| s == "unknown" }
+
+        if statuses.include?("eol")
+          "eol"
+        elsif statuses.include?("warning")
+          "warning"
+        else
+          "safe"
+        end
+      end
+
+      def days_until(date_string)
+        eol_date = Date.parse(date_string)
+        (eol_date - Date.today).to_i
+      end
+    end
+  end
+end