stackharbinger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78f93c3813cf5f8ec4540a11d5901f4832667fc76ac449c2cbc61899d61844af
+  data.tar.gz: a713dcab3bf69bd8ba1bf3aa7ff26d841e2beff17a15ba5a4b33918338b4d093
+SHA512:
+  metadata.gz: '07888386c6149bbef7a607766cd92c59d34c2f38bdddd6dc06a97fb1734f21b9b5775c47fe5f54c81e71a459931b24dac9f3c3dbd30d49d63bdca8bd19fed3cc'
+  data.tar.gz: 223b899768d2c1d6e7ad2bbfd5df74679e119e8d0d79b235b401035587e23dba52c624b86f831686f5d93fbd91177b245b60cb582291d22c5b3520ff11733f3e

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-01-18
+
+### Added
+- Ruby version detection from `.ruby-version`, `Gemfile`, and `Gemfile.lock`
+- Rails version detection from `Gemfile.lock`
+- EOL data fetching from endoflife.date API
+- Smart caching with 24-hour expiry
+- CLI commands:
+  - `harbinger scan [PATH]` - Scan project and show EOL status
+  - `harbinger update` - Force refresh EOL data
+  - `harbinger version` - Show harbinger version
+- Color-coded status display:
+  - Red: Already EOL or <30 days remaining
+  - Yellow: <6 months remaining
+  - Green: >6 months remaining
+- Product detection with helpful guidance when version not specified
+- Comprehensive test suite (36 tests)
+- Automatic EOL data fetch on first scan (zero configuration)
+
+### Technical
+- Built with Thor for CLI framework
+- HTTParty for HTTP requests
+- TTY gems for terminal UI
+- RSpec for testing
+- RuboCop for linting

data/README.md

@@ -0,0 +1,180 @@
+# Harbinger
+
+**Track End-of-Life dates for your tech stack and stay ahead of deprecations.**
+
+Harbinger is a CLI tool that scans your Ruby and Rails projects, detects versions, and warns you about upcoming EOL (End-of-Life) dates. Never get caught off-guard by unsupported dependencies again.
+
+## Features
+
+- 🔍 **Auto-detects versions** from `.ruby-version`, `Gemfile`, and `Gemfile.lock`
+- 📅 **Fetches EOL data** from [endoflife.date](https://endoflife.date)
+- 🎨 **Color-coded warnings** (red: already EOL, yellow: <6 months, green: safe)
+- ⚡ **Smart caching** (24-hour cache, works offline after first fetch)
+- 🚀 **Zero configuration** - just run `harbinger scan`
+
+## Installation
+
+```bash
+gem install stackharbinger
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'stackharbinger'
+```
+
+The command is still `harbinger` (shorter to type).
+
+## Usage
+
+### Scan a project
+
+```bash
+# Scan current directory
+harbinger scan
+
+# Scan specific project
+harbinger scan ~/Projects/my-rails-app
+```
+
+**Example output:**
+
+```
+Scanning /Users/you/Projects/my-app...
+
+Detected versions:
+  Ruby:  3.2.0
+  Rails: 7.0.8
+
+Fetching EOL data...
+
+Ruby 3.2.0:
+  EOL Date: 2026-03-31
+  Status:   437 days remaining
+
+Rails 7.0.8:
+  EOL Date: 2025-06-01
+  Status:   ALREADY EOL (474 days ago)
+```
+
+### Update EOL data
+
+```bash
+# Force refresh EOL data from endoflife.date
+harbinger update
+```
+
+### Show version
+
+```bash
+harbinger version
+```
+
+## How It Works
+
+1. **Detection**: Harbinger looks for version info in your project:
+   - Ruby: `.ruby-version`, `Gemfile` (`ruby "x.x.x"`), `Gemfile.lock` (RUBY VERSION)
+   - Rails: `Gemfile.lock` (rails gem)
+
+2. **EOL Data**: Fetches official EOL dates from [endoflife.date](https://endoflife.date) API
+
+3. **Caching**: Stores data in `~/.harbinger/data/` for 24 hours (works offline)
+
+4. **Analysis**: Compares your versions against EOL dates and color-codes the urgency
+
+## Version Detection
+
+### Ruby Detection Priority
+
+1. `.ruby-version` file (highest priority)
+2. `ruby "x.x.x"` declaration in Gemfile
+3. `RUBY VERSION` section in Gemfile.lock
+
+If Harbinger detects a Ruby project but no version:
+```
+Ruby:  Present (version not specified - add .ruby-version or ruby declaration in Gemfile)
+```
+
+### Rails Detection
+
+Parses `Gemfile.lock` for the rails gem version.
+
+## Requirements
+
+- Ruby >= 3.1.0
+- Internet connection (for initial EOL data fetch)
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/RichD/harbinger.git
+cd harbinger
+
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Run locally
+bundle exec exe/harbinger scan .
+```
+
+## Roadmap
+
+### V0.1.0 (Beta) - Current
+- ✅ Ruby and Rails version detection
+- ✅ EOL data fetching and caching
+- ✅ CLI with scan and update commands
+- ✅ Color-coded status display
+
+### V0.2.0 - Planned
+- 📊 Dashboard: `harbinger show` to see all tracked projects
+- 💾 Config management: Save and track multiple projects
+- 🐘 PostgreSQL version detection
+- 🗄️ MySQL version detection
+
+### V1.0 - Future
+- 🐍 Python support (pyproject.toml, requirements.txt)
+- 📦 Node.js support (package.json, .nvmrc)
+- 🦀 Rust support (Cargo.toml)
+- 🏠 Homebrew distribution: `brew install harbinger`
+
+### V2.0 - Vision
+- 🤖 AI-powered upgrade summaries
+- 📧 Email/Slack notifications
+- ☁️ Cloud platform detection (AWS, Heroku, etc.)
+- 👥 Team collaboration features
+
+## Contributing
+
+Contributions welcome! Please:
+
+1. Fork the repo
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Write tests for your changes
+4. Ensure all tests pass (`bundle exec rspec`)
+5. Commit your changes (`git commit -m 'Add amazing feature'`)
+6. Push to the branch (`git push origin feature/amazing-feature`)
+7. Open a Pull Request
+
+## License
+
+This gem is available as open source under the terms of the MIT License.
+
+## Credits
+
+- EOL data provided by [endoflife.date](https://endoflife.date)
+- Built with ❤️ using Ruby and Thor
+
+## Links
+
+- Website: [stackharbinger.com](https://stackharbinger.com)
+- GitHub: [github.com/RichD/harbinger](https://github.com/RichD/harbinger)
+- RubyGems: [rubygems.org/gems/stackharbinger](https://rubygems.org/gems/stackharbinger)
+
+---
+
+**Like Harbinger?** Give it a ⭐ on GitHub!

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/harbinger

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "harbinger/cli"
+
+Harbinger::CLI.start(ARGV)

data/lib/harbinger/analyzers/rails_analyzer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Harbinger
+  module Analyzers
+    class RailsAnalyzer
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      def detect
+        detect_from_gemfile_lock
+      end
+
+      def rails_detected?
+        gemfile_lock = File.join(project_path, "Gemfile.lock")
+        return false unless File.exist?(gemfile_lock)
+
+        content = File.read(gemfile_lock)
+        content.match?(/^\s*rails\s+\(/)
+      rescue StandardError
+        false
+      end
+
+      private
+
+      attr_reader :project_path
+
+      def detect_from_gemfile_lock
+        file_path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        match = content.match(/^\s*rails\s+\(([^)]+)\)/)
+        match ? match[1] : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/ruby_detector.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Harbinger
+  module Analyzers
+    class RubyDetector
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      def detect
+        detect_from_ruby_version ||
+          detect_from_gemfile ||
+          detect_from_gemfile_lock
+      end
+
+      def ruby_detected?
+        File.exist?(File.join(project_path, "Gemfile")) ||
+          File.exist?(File.join(project_path, "Gemfile.lock")) ||
+          File.exist?(File.join(project_path, ".ruby-version"))
+      end
+
+      private
+
+      attr_reader :project_path
+
+      def detect_from_ruby_version
+        file_path = File.join(project_path, ".ruby-version")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path).strip
+        extract_version(content)
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile
+        file_path = File.join(project_path, "Gemfile")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        match = content.match(/ruby\s+["']([^"']+)["']/)
+        match ? match[1] : nil
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile_lock
+        file_path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        match = content.match(/RUBY VERSION\s+ruby\s+([^\s]+)/)
+        match ? extract_version(match[1]) : nil
+      rescue StandardError
+        nil
+      end
+
+      def extract_version(version_string)
+        # Remove "ruby-" prefix if present
+        version = version_string.sub(/^ruby-/, "")
+        # Remove patch level suffix (e.g., "p223")
+        version.sub(/p\d+$/, "")
+      end
+    end
+  end
+end

data/lib/harbinger/cli.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "thor"
+require "date"
+require_relative "version"
+require "harbinger/analyzers/ruby_detector"
+require "harbinger/analyzers/rails_analyzer"
+require "harbinger/eol_fetcher"
+
+module Harbinger
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "scan [PATH]", "Scan a project directory and detect versions"
+    option :path, type: :string, aliases: "-p", desc: "Path to project directory"
+    def scan(path = nil)
+      project_path = path || options[:path] || Dir.pwd
+
+      unless File.directory?(project_path)
+        say "Error: #{project_path} is not a valid directory", :red
+        exit 1
+      end
+
+      say "Scanning #{project_path}...", :cyan
+
+      # Detect versions
+      ruby_detector = Analyzers::RubyDetector.new(project_path)
+      rails_analyzer = Analyzers::RailsAnalyzer.new(project_path)
+
+      ruby_version = ruby_detector.detect
+      rails_version = rails_analyzer.detect
+
+      ruby_present = ruby_detector.ruby_detected?
+      rails_present = rails_analyzer.rails_detected?
+
+      # Display results
+      say "\nDetected versions:", :green
+      if ruby_version
+        say "  Ruby:  #{ruby_version}", :white
+      elsif ruby_present
+        say "  Ruby:  Present (version not specified - add .ruby-version or ruby declaration in Gemfile)", :yellow
+      else
+        say "  Ruby:  Not a Ruby project", :red
+      end
+
+      if rails_version
+        say "  Rails: #{rails_version}", :white
+      elsif rails_present
+        say "  Rails: Present (version not found in Gemfile.lock)", :yellow
+      else
+        say "  Rails: Not detected", :yellow
+      end
+
+      # Fetch and display EOL dates
+      if ruby_version || rails_version
+        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
+      end
+    end
+
+    desc "show", "Show EOL status for tracked projects"
+    def show
+      say "Show command coming soon!", :yellow
+      say "Use 'harbinger scan' to check a project's EOL status", :white
+    end
+
+    desc "update", "Force refresh EOL data from endoflife.date"
+    def update
+      say "Updating EOL data...", :cyan
+
+      fetcher = EolFetcher.new
+      products = %w[ruby rails]
+
+      products.each do |product|
+        say "Fetching #{product}...", :white
+        data = fetcher.fetch(product)
+
+        if data
+          say "  ✓ #{product.capitalize}: #{data.length} versions cached", :green
+        else
+          say "  ✗ #{product.capitalize}: Failed to fetch", :red
+        end
+      end
+
+      say "\nEOL data updated successfully!", :green
+    end
+
+    desc "version", "Show harbinger version"
+    def version
+      say "Harbinger version #{Harbinger::VERSION}", :cyan
+    end
+
+    private
+
+    def display_eol_info(fetcher, product, version)
+      product_key = product.downcase
+      eol_date = fetcher.eol_date_for(product_key, version)
+
+      if eol_date
+        days_until_eol = days_until(eol_date)
+        color = eol_color(days_until_eol)
+
+        say "\n#{product} #{version}:", :white
+        say "  EOL Date: #{eol_date}", color
+        say "  Status:   #{eol_status(days_until_eol)}", color
+      else
+        say "\n#{product} #{version}:", :white
+        say "  EOL Date: Unknown (version not found in database)", :yellow
+      end
+    end
+
+    def days_until(date_string)
+      eol_date = Date.parse(date_string)
+      (eol_date - Date.today).to_i
+    end
+
+    def eol_color(days)
+      if days < 0
+        :red
+      elsif days < 180 # < 6 months
+        :yellow
+      else
+        :green
+      end
+    end
+
+    def eol_status(days)
+      if days < 0
+        "ALREADY EOL (#{days.abs} days ago)"
+      elsif days < 30
+        "ENDING SOON (#{days} days remaining)"
+      elsif days < 180
+        "#{days} days remaining"
+      else
+        "#{days} days remaining"
+      end
+    end
+  end
+end

data/lib/harbinger/eol_fetcher.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "json"
+require "fileutils"
+
+module Harbinger
+  class EolFetcher
+    CACHE_EXPIRY_SECONDS = 24 * 60 * 60 # 24 hours
+    API_BASE_URL = "https://endoflife.date/api"
+
+    def initialize(cache_dir: default_cache_dir)
+      @cache_dir = cache_dir
+      FileUtils.mkdir_p(@cache_dir)
+    end
+
+    def fetch(product)
+      cache_file = cache_file_path(product)
+
+      # Return fresh cache if available
+      if cache_fresh?(cache_file)
+        return read_cache(cache_file)
+      end
+
+      # Try to fetch from API
+      begin
+        data = fetch_from_api(product)
+        write_cache(cache_file, data)
+        data
+      rescue StandardError => e
+        # Fall back to stale cache if API fails
+        read_cache(cache_file) if File.exist?(cache_file)
+      end
+    end
+
+    def eol_date_for(product, version)
+      data = fetch(product)
+      return nil unless data
+
+      # Extract major.minor from version (e.g., "3.2.1" -> "3.2")
+      version_parts = version.split(".")
+      major_minor = "#{version_parts[0]}.#{version_parts[1]}"
+
+      # Find matching cycle
+      entry = data.find { |item| item["cycle"] == major_minor }
+      entry ? entry["eol"] : nil
+    end
+
+    private
+
+    attr_reader :cache_dir
+
+    def default_cache_dir
+      File.join(Dir.home, ".harbinger", "data")
+    end
+
+    def cache_file_path(product)
+      File.join(cache_dir, "#{product}.json")
+    end
+
+    def cache_fresh?(cache_file)
+      return false unless File.exist?(cache_file)
+
+      File.mtime(cache_file) > Time.now - CACHE_EXPIRY_SECONDS
+    end
+
+    def read_cache(cache_file)
+      return nil unless File.exist?(cache_file)
+
+      JSON.parse(File.read(cache_file))
+    rescue StandardError
+      nil
+    end
+
+    def write_cache(cache_file, data)
+      File.write(cache_file, JSON.pretty_generate(data))
+    rescue StandardError
+      # Silently fail if we can't write cache
+      nil
+    end
+
+    def fetch_from_api(product)
+      url = "#{API_BASE_URL}/#{product}.json"
+      response = HTTParty.get(url)
+
+      raise "API request failed: #{response.code}" unless response.success?
+
+      response.parsed_response
+    end
+  end
+end

data/lib/harbinger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Harbinger
+  VERSION = "0.1.0"
+end

data/lib/harbinger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "harbinger/version"
+require_relative "harbinger/cli"
+require_relative "harbinger/analyzers/ruby_detector"
+require_relative "harbinger/analyzers/rails_analyzer"
+require_relative "harbinger/eol_fetcher"
+
+module Harbinger
+  class Error < StandardError; end
+end

data/sig/harbinger.rbs

@@ -0,0 +1,4 @@
+module Harbinger
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: stackharbinger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rich Dabrowski
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+description: Harbinger monitors EOL dates for Ruby, Rails, PostgreSQL and other technologies
+  in your stack. Auto-detects versions from your projects and alerts you before support
+  ends.
+email:
+- engineering@richd.net
+executables:
+- harbinger
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- exe/harbinger
+- lib/harbinger.rb
+- lib/harbinger/analyzers/rails_analyzer.rb
+- lib/harbinger/analyzers/ruby_detector.rb
+- lib/harbinger/cli.rb
+- lib/harbinger/eol_fetcher.rb
+- lib/harbinger/version.rb
+- sig/harbinger.rbs
+homepage: https://stackharbinger.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://stackharbinger.com
+  source_code_uri: https://github.com/RichD/harbinger
+  changelog_uri: https://github.com/RichD/harbinger/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Track End-of-Life dates for your tech stack and stay ahead of deprecations
+test_files: []