stackharbinger 0.3.0 → 1.0.0

data/lib/harbinger/analyzers/go_detector.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Harbinger
+  module Analyzers
+    class GoDetector
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      def detect
+        version = detect_from_go_mod ||
+                  detect_from_go_work ||
+                  detect_from_go_version_file ||
+                  detect_from_docker_compose ||
+                  detect_from_shell
+
+        normalize_version(version) if version
+      end
+
+      def go_detected?
+        File.exist?(File.join(@project_path, "go.mod")) ||
+          File.exist?(File.join(@project_path, "go.work")) ||
+          File.exist?(File.join(@project_path, ".go-version"))
+      end
+
+      private
+
+      def detect_from_go_mod
+        go_mod_path = File.join(@project_path, "go.mod")
+        return nil unless File.exist?(go_mod_path)
+
+        content = File.read(go_mod_path)
+        # Match "go 1.21" or "go 1.21.0" format
+        match = content.match(/^go\s+([\d.]+)/m)
+        match[1] if match
+      end
+
+      def detect_from_go_work
+        go_work_path = File.join(@project_path, "go.work")
+        return nil unless File.exist?(go_work_path)
+
+        content = File.read(go_work_path)
+        # Match "go 1.21" or "go 1.21.0" format
+        match = content.match(/^go\s+([\d.]+)/m)
+        match[1] if match
+      end
+
+      def detect_from_go_version_file
+        go_version_path = File.join(@project_path, ".go-version")
+        return nil unless File.exist?(go_version_path)
+
+        version = File.read(go_version_path).strip
+        version unless version.empty?
+      end
+
+      def detect_from_docker_compose
+        docker_compose_path = File.join(@project_path, "docker-compose.yml")
+        return nil unless File.exist?(docker_compose_path)
+
+        content = File.read(docker_compose_path)
+        # Match golang:1.21, golang:1.21.0, golang:1.21-alpine, etc.
+        match = content.match(/golang:([\d.]+)/)
+        match[1] if match
+      end
+
+      def detect_from_shell
+        # Only try shell detection if Go project files exist
+        return nil unless go_detected?
+
+        version_output = `go version 2>/dev/null`.strip
+        return nil if version_output.empty?
+
+        # Parse "go version go1.21.0 darwin/amd64" format
+        match = version_output.match(/go version go([\d.]+)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def normalize_version(version)
+        # Remove any trailing qualifiers like -alpine, -rc1, etc.
+        version.gsub(/-(alpine|rc\d+|beta\d*).*/, "")
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/mongo_detector.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects MongoDB version from projects
+    class MongoDetector
+      attr_reader :project_path
+
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      # Main detection method - returns version string or nil
+      def detect
+        return nil unless mongo_detected?
+
+        # Try docker-compose.yml first
+        version = detect_from_docker_compose
+        return version if version
+
+        # Try shell command
+        version = detect_from_shell
+        return version if version
+
+        # Fallback to gem version
+        detect_from_gemfile_lock
+      end
+
+      # Check if MongoDB is used in this project
+      def mongo_detected?
+        gemfile_has_mongo? || docker_compose_has_mongo?
+      end
+
+      private
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("mongo")
+      end
+
+      def detect_from_shell
+        # Try mongosh first (modern shell, MongoDB 5+)
+        output = `mongosh --version 2>&1`.strip
+        return output if $CHILD_STATUS.success? && output.match?(/^\d+\.\d+/)
+
+        # Try legacy mongo shell
+        output = `mongo --version 2>&1`.strip
+        if $CHILD_STATUS.success?
+          match = output.match(/MongoDB shell version v?(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        # Fall back to mongod (server)
+        output = `mongod --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        match = output.match(/db version v(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile_lock
+        content = read_gemfile_lock
+        return nil unless content
+
+        # Look for mongoid gem version first (most common for Rails)
+        match = content.match(/^\s{4}mongoid\s+\(([^)]+)\)/)
+        return "#{match[1]} (mongoid gem)" if match
+
+        # Fall back to mongo gem
+        match = content.match(/^\s{4}mongo\s+\(([^)]+)\)/)
+        return "#{match[1]} (mongo gem)" if match
+
+        nil
+      end
+
+      def gemfile_has_mongo?
+        content = read_gemfile_lock
+        return false unless content
+
+        content.include?("mongoid (") || content.include?("mongo (")
+      end
+
+      def docker_compose_has_mongo?
+        docker = DockerComposeDetector.new(project_path)
+        return false unless docker.docker_compose_exists?
+
+        docker.image_version("mongo") != nil
+      end
+
+      def read_gemfile_lock
+        path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(path)
+
+        File.read(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/mysql_detector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "database_detector"
+require_relative "docker_compose_detector"
 
 module Harbinger
   module Analyzers
@@ -10,7 +11,13 @@ module Harbinger
       protected
 
       def adapter_name
-        ["mysql2", "trilogy"]
+        %w[mysql2 trilogy]
+      end
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        # Try mysql first, then mariadb
+        docker.image_version("mysql") || docker.image_version("mariadb")
       end
 
       def detect_from_shell

data/lib/harbinger/analyzers/node_detector.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "docker_compose_detector"
+require "json"
+
+module Harbinger
+  module Analyzers
+    class NodeDetector
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      def detect
+        detect_from_version_files ||
+          detect_from_package_json ||
+          detect_from_docker_compose ||
+          (nodejs_detected? ? detect_from_shell : nil)
+      end
+
+      def nodejs_detected?
+        File.exist?(File.join(project_path, "package.json")) ||
+          File.exist?(File.join(project_path, "package-lock.json")) ||
+          File.exist?(File.join(project_path, ".nvmrc")) ||
+          File.exist?(File.join(project_path, ".node-version")) ||
+          File.exist?(File.join(project_path, "node_modules"))
+      rescue StandardError
+        false
+      end
+
+      private
+
+      attr_reader :project_path
+
+      def detect_from_version_files
+        [".nvmrc", ".node-version"].each do |filename|
+          file_path = File.join(project_path, filename)
+          next unless File.exist?(file_path)
+
+          content = File.read(file_path).strip
+          next if content.empty?
+
+          return extract_version(content)
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_package_json
+        file_path = File.join(project_path, "package.json")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        package = JSON.parse(content)
+
+        engines = package.dig("engines", "node")
+        return nil unless engines
+
+        extract_version(engines)
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("node")
+      end
+
+      def detect_from_shell
+        output = `node --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        # Parse: "v18.16.0" (note the 'v' prefix)
+        match = output.match(/^v?(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def extract_version(version_string)
+        # Remove 'v' prefix (Node.js convention)
+        version = version_string.sub(/^v/, "")
+
+        # Strip constraint operators: >=18.0.0, ^18.0.0, ~18.0.0
+        version = version.gsub(/^[><=~^!\s]+/, "")
+
+        # Handle ranges like ">=14.0.0 <20.0.0" - extract first version
+        version = version.split(/\s+/).first if version.include?(" ")
+
+        # Handle .x suffix (e.g., "18.x" => "18")
+        version = version.sub(/\.x$/, "")
+
+        # Handle LTS names like "lts/hydrogen" (hydrogen=18, gallium=16, fermium=14)
+        if version =~ /lts\/(hydrogen|gallium|fermium)/i
+          lts_name = $1.downcase
+          return case lts_name
+                 when "hydrogen" then "18"
+                 when "gallium" then "16"
+                 when "fermium" then "14"
+                 else nil
+                 end
+        end
+
+        version
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/postgres_detector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "database_detector"
+require_relative "docker_compose_detector"
 
 module Harbinger
   module Analyzers
@@ -12,6 +13,11 @@ module Harbinger
         "postgresql"
       end
 
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("postgres")
+      end
+
       def detect_from_shell
         # Skip shell command if database is remote
         # (shell gives client version, not server version)

data/lib/harbinger/analyzers/python_detector.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Harbinger
+  module Analyzers
+    class PythonDetector
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      def detect
+        detect_from_pyproject_toml ||
+          detect_from_python_version ||
+          detect_from_pyvenv_cfg ||
+          (python_detected? ? detect_from_shell : nil)
+      end
+
+      def python_detected?
+        File.exist?(File.join(project_path, "pyproject.toml")) ||
+          File.exist?(File.join(project_path, "requirements.txt")) ||
+          File.exist?(File.join(project_path, ".python-version")) ||
+          File.exist?(File.join(project_path, "setup.py")) ||
+          File.exist?(File.join(project_path, "setup.cfg")) ||
+          venv_exists?
+      end
+
+      private
+
+      attr_reader :project_path
+
+      def detect_from_pyproject_toml
+        file_path = File.join(project_path, "pyproject.toml")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+
+        # Try [project] requires-python = ">=3.11"
+        match = content.match(/requires-python\s*=\s*["']([^"']+)["']/)
+        return extract_version(match[1]) if match
+
+        # Try [tool.poetry.dependencies] python = "^3.11"
+        match = content.match(/\[tool\.poetry\.dependencies\].*?python\s*=\s*["']([^"']+)["']/m)
+        return extract_version(match[1]) if match
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_python_version
+        file_path = File.join(project_path, ".python-version")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path).strip
+        extract_version(content)
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_pyvenv_cfg
+        ["venv/pyvenv.cfg", ".venv/pyvenv.cfg"].each do |cfg_path|
+          file_path = File.join(project_path, cfg_path)
+          next unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          # Parse: "version = 3.11.5"
+          match = content.match(/version\s*=\s*(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_shell
+        # Try python3 first (more reliable on multi-Python systems)
+        output = `python3 --version 2>&1`.strip
+        if $CHILD_STATUS.success?
+          match = output.match(/Python\s+(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        # Fall back to python
+        output = `python --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        match = output.match(/Python\s+(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def extract_version(version_string)
+        # Strip constraint operators: >=3.11, ^3.11, ~3.11, >3.11, <4.0
+        version = version_string.gsub(/^[><=~^!\s]+/, "")
+
+        # Handle ranges like ">=3.9,<4.0" - extract first version
+        version = version.split(",").first.strip if version.include?(",")
+
+        # Remove "python-" prefix if present (from .python-version)
+        version.sub(/^python-/, "")
+      end
+
+      def venv_exists?
+        File.exist?(File.join(project_path, "venv/pyvenv.cfg")) ||
+          File.exist?(File.join(project_path, ".venv/pyvenv.cfg"))
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/rails_analyzer.rb

@@ -31,7 +31,11 @@ module Harbinger
 
         content = File.read(file_path)
         match = content.match(/^\s*rails\s+\(([^)]+)\)/)
-        match ? match[1] : nil
+        return nil unless match
+
+        version_string = match[1]
+        # Strip version constraint operators (>=, ~>, =, etc.) and extract actual version
+        version_string.sub(/^[><=~!\s]+/, "").strip
       rescue StandardError
         nil
       end

data/lib/harbinger/analyzers/redis_detector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects Redis version from projects
+    class RedisDetector
+      attr_reader :project_path
+
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      # Main detection method - returns version string or nil
+      def detect
+        return nil unless redis_detected?
+
+        # Try docker-compose.yml first
+        version = detect_from_docker_compose
+        return version if version
+
+        # Try shell command
+        version = detect_from_shell
+        return version if version
+
+        # Fallback to gem version
+        detect_from_gemfile_lock
+      end
+
+      # Check if Redis is used in this project
+      def redis_detected?
+        gemfile_has_redis? || docker_compose_has_redis?
+      end
+
+      private
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("redis")
+      end
+
+      def detect_from_shell
+        # Try redis-cli first (more commonly available)
+        output = `redis-cli -v 2>&1`.strip
+        if $CHILD_STATUS.success?
+          # Parse: "redis-cli 7.0.5"
+          match = output.match(/redis-cli\s+(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        # Fall back to redis-server
+        output = `redis-server --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        # Parse: "Redis server v=7.2.4 sha=..."
+        match = output.match(/v=(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile_lock
+        content = read_gemfile_lock
+        return nil unless content
+
+        # Look for redis gem version
+        match = content.match(/^\s{4}redis\s+\(([^)]+)\)/)
+        return "#{match[1]} (gem)" if match
+
+        nil
+      end
+
+      def gemfile_has_redis?
+        content = read_gemfile_lock
+        return false unless content
+
+        content.include?("redis (")
+      end
+
+      def docker_compose_has_redis?
+        docker = DockerComposeDetector.new(project_path)
+        return false unless docker.docker_compose_exists?
+
+        docker.image_version("redis") != nil
+      end
+
+      def read_gemfile_lock
+        path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(path)
+
+        File.read(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/ruby_detector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "docker_compose_detector"
+
 module Harbinger
   module Analyzers
     class RubyDetector
@@ -10,7 +12,8 @@ module Harbinger
       def detect
         detect_from_ruby_version ||
           detect_from_gemfile ||
-          detect_from_gemfile_lock
+          detect_from_gemfile_lock ||
+          detect_from_dockerfile
       end
 
       def ruby_detected?
@@ -61,6 +64,11 @@ module Harbinger
         # Remove patch level suffix (e.g., "p223")
         version.sub(/p\d+$/, "")
       end
+
+      def detect_from_dockerfile
+        docker = DockerComposeDetector.new(project_path)
+        docker.ruby_version_from_dockerfile
+      end
     end
   end
 end