gem-digest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59ea827e8f6823c9eb9b56aad62ac5216b5153bd86c540c6639a95ac490572f8
+  data.tar.gz: c20cb62a7397459d636ef26306cb5261d9b7a9bdd6ddb2f564d2f1d73f6bcf39
+SHA512:
+  metadata.gz: 55e07ba173fab062e7a3416db93caa2259baa1b3a51146d310266d94b92d1c9cdee9d74f8ae9f4c9306741a40f02ca00fd3d73374ea4fb6c18f6159075e62d56
+  data.tar.gz: 4d42813be1e897c0393756886a10352b35961e5ef7c94bf71201b51e538bf1c55708f5957e1f7c947bc77797ce8a40ce131be81b3d20587810719ebfbd4fae05

data/DEVELOPMENT.md

@@ -0,0 +1,241 @@
+# 🛠️ Development Guide
+
+This document provides detailed information for developers working on gem-digest.
+
+## 🏗️ Project Structure
+
+```
+gem-digest/
+├── .github/workflows/release.yml  # CI/CD pipeline
+├── bin/console                     # Interactive console
+├── exe/gemd                       # Main executable
+├── lib/
+│   ├── gem_digest.rb              # Main module
+│   └── gem_digest/
+│       ├── analyzer.rb            # Gemfile.lock parser
+│       ├── categorizer.rb         # Version categorization
+│       ├── changelog_fetcher.rb   # Changelog integration
+│       ├── cli.rb                 # Command-line interface
+│       ├── reporters/             # Output formatters
+│       │   ├── base.rb
+│       │   ├── console.rb
+│       │   └── markdown.rb
+│       └── version.rb             # Version constant
+├── spec/                          # Test suite
+├── output/                        # Generated reports
+└── config/                        # Configuration files
+```
+
+## 🧪 Testing
+
+### Running Tests
+
+```bash
+# Install dependencies
+bundle install
+
+# Run all tests
+bundle exec rspec
+
+# Run specific test files
+bundle exec rspec spec/gem_digest/analyzer_spec.rb
+bundle exec rspec spec/integration_spec.rb
+
+# Run with coverage
+bundle exec rspec --format documentation
+```
+
+### Test Structure
+
+- **Unit Tests**: Test individual classes and methods
+- **Integration Tests**: Test the complete workflow
+- **Mock Network Calls**: Avoid hitting RubyGems API during tests
+
+### Adding New Tests
+
+1. Create test files in `spec/gem_digest/`
+2. Follow the naming convention: `*_spec.rb`
+3. Use RSpec best practices
+4. Mock external dependencies
+
+## 🔧 Development Workflow
+
+### Local Development
+
+```bash
+# Clone the repository
+git clone https://github.com/ND-Zyth/gem-digest.git
+cd gem-digest
+
+# Install dependencies
+bundle install
+
+# Run the tool locally
+bundle exec ruby -Ilib exe/gemd analyze
+
+# Or use the simple CLI for testing
+ruby simple_cli.rb test_Gemfile.lock
+```
+
+### Code Quality
+
+```bash
+# Run RuboCop for style checking
+bundle exec rubocop
+
+# Auto-fix issues
+bundle exec rubocop -a
+
+# Check specific files
+bundle exec rubocop lib/gem_digest/analyzer.rb
+```
+
+### Building and Testing the Gem
+
+```bash
+# Build the gem
+gem build gem-digest.gemspec
+
+# Install locally for testing
+gem install gem-digest-*.gem
+
+# Test the installed gem
+gemd analyze
+```
+
+## 📦 Release Process
+
+### Version Management
+
+1. Update version in `lib/gem_digest/version.rb`
+2. Update `CHANGELOG.md` with new features/fixes
+3. Commit changes: `git commit -m "Bump version to X.Y.Z"`
+4. Create and push tag: `git tag vX.Y.Z && git push origin vX.Y.Z`
+
+### Automated Release
+
+The GitHub Actions workflow automatically:
+1. Runs tests on multiple Ruby versions and platforms
+2. Builds gems for each platform
+3. Creates a GitHub release with attached gem files
+4. Publishes to RubyGems (requires `RUBYGEMS_API_KEY` secret)
+
+## 🏛️ Architecture
+
+### Core Components
+
+1. **Analyzer**: Parses `Gemfile.lock` using Bundler and fetches latest versions from RubyGems API
+2. **Categorizer**: Compares versions using semantic versioning rules
+3. **Reporters**: Generate output in different formats (console, markdown)
+4. **CLI**: Provides user-friendly command-line interface
+
+### Data Flow
+
+```
+Gemfile.lock → Analyzer → Categorizer → Reporter → Output
+```
+
+### API Design
+
+The gem provides both CLI and programmatic interfaces:
+
+```ruby
+# Programmatic usage
+GemDigest.analyze("path/to/Gemfile.lock", format: "console")
+
+# Individual components
+analyzer = GemDigest::Analyzer.new("Gemfile.lock")
+gems_data = analyzer.analyze
+
+categorizer = GemDigest::Categorizer.new
+categorized = categorizer.categorize(gems_data)
+
+reporter = GemDigest::Reporters::Console.new
+reporter.generate_report(categorized)
+```
+
+## 🔌 Adding New Features
+
+### New Output Format
+
+1. Create new reporter class in `lib/gem_digest/reporters/`
+2. Inherit from `GemDigest::Reporters::Base`
+3. Implement `generate_report` method
+4. Add format option to CLI and main module
+
+### New Analysis Features
+
+1. Extend `Analyzer` class with new methods
+2. Update `Categorizer` if new categorization is needed
+3. Add corresponding tests
+4. Update documentation
+
+### Configuration Support
+
+1. Add configuration file parsing
+2. Extend CLI options
+3. Update reporters to use configuration
+4. Add configuration validation
+
+## 🐛 Debugging
+
+### Common Issues
+
+1. **Network Timeouts**: RubyGems API calls may timeout
+   - Solution: Add retry logic and better error handling
+
+2. **Version Parsing**: Complex version strings may not parse correctly
+   - Solution: Improve version parsing in `Categorizer`
+
+3. **Large Gemfiles**: Performance issues with many gems
+   - Solution: Add parallel processing or caching
+
+### Debug Mode
+
+Enable verbose output for debugging:
+
+```bash
+gemd analyze --verbose
+```
+
+### Logging
+
+Add debug logging to track execution:
+
+```ruby
+puts "Debug: Processing gem #{gem_name}" if options[:verbose]
+```
+
+## 📚 Dependencies
+
+### Runtime Dependencies
+
+- `bundler ~> 2.0`: For parsing Gemfile.lock
+- `commander ~> 4.5`: CLI framework
+- `pastel ~> 0.8`: Colored output
+- `tty-table ~> 0.12`: Formatted tables
+
+### Development Dependencies
+
+- `rspec ~> 3.0`: Testing framework
+- `rake ~> 13.0`: Build tasks
+- `rubocop ~> 1.21`: Code style checking
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/new-feature`
+3. Make changes and add tests
+4. Run tests: `bundle exec rspec`
+5. Check code style: `bundle exec rubocop`
+6. Commit changes: `git commit -m "Add new feature"`
+7. Push branch: `git push origin feature/new-feature`
+8. Create pull request
+
+### Code Style
+
+- Follow Ruby community standards
+- Use RuboCop for style checking
+- Write descriptive commit messages
+- Add tests for new features
+- Update documentation as needed

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 ND-Zyth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# 💎 Gem Digest
+
+A powerful CLI tool that analyzes your `Gemfile.lock`, fetches the latest gem versions from RubyGems, and categorizes updates by semantic versioning (major, minor, patch).
+
+## 🚀 Features
+
+- **Smart Analysis**: Parses `Gemfile.lock` and compares with latest versions from RubyGems
+- **Semantic Categorization**: Groups updates by major, minor, and patch versions
+- **Multiple Output Formats**: Console output with colors and tables, or Markdown reports
+- **Comprehensive Reporting**: Shows current vs latest versions with source information
+- **Cross-Platform**: Works on Linux, macOS, and Windows
+
+## 📦 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gem-digest'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install gem-digest
+```
+
+## 🛠️ Usage
+
+### Basic Analysis
+
+Analyze your current directory's `Gemfile.lock`:
+
+```bash
+$ gemd analyze
+```
+
+### Advanced Options
+
+```bash
+# Specify a different Gemfile.lock path
+$ gemd analyze --gemfile-lock /path/to/Gemfile.lock
+
+# Generate a markdown report
+$ gemd analyze --format markdown --output-dir reports
+
+# Show gems that are already up to date
+$ gemd analyze --show-up-to-date
+
+# Verbose output
+$ gemd analyze --verbose
+```
+
+### Example Output
+
+```
+🔍 Gem Digest Analysis Summary
+==================================================
+📦 Total gems analyzed: 25
+🔴 Major updates available: 3
+🟡 Minor updates available: 8
+🟢 Patch updates available: 12
+✅ Up to date: 2
+
+Major Updates (3)
+─────────────────
+┌─────────────┬─────────┬────────┬───────────┐
+│ Gem         │ Current │ Latest │ Source    │
+├─────────────┼─────────┼────────┼───────────┤
+│ rails       │ 6.1.7   │ 7.0.4  │ rubygems  │
+│ rspec       │ 3.11.0  │ 4.0.0  │ rubygems  │
+│ sidekiq     │ 6.5.8   │ 7.0.2  │ rubygems  │
+└─────────────┴─────────┴────────┴───────────┘
+```
+
+## 🏗️ Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Running Tests
+
+```bash
+$ bundle exec rspec
+```
+
+### Code Quality
+
+```bash
+$ bundle exec rubocop
+```
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ND-Zyth/gem-digest.
+
+## 📄 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## 🔧 API Reference
+
+### GemDigest Module
+
+```ruby
+# Analyze gems programmatically
+GemDigest.analyze("path/to/Gemfile.lock", format: "console")
+GemDigest.analyze("path/to/Gemfile.lock", format: "markdown", output_dir: "reports")
+```
+
+### Classes
+
+- `GemDigest::Analyzer` - Parses Gemfile.lock and fetches latest versions
+- `GemDigest::Categorizer` - Categorizes gems by update type
+- `GemDigest::Reporters::Console` - Generates colored console output
+- `GemDigest::Reporters::Markdown` - Generates markdown reports
+- `GemDigest::CLI` - Command-line interface
+
+## 🎯 Roadmap
+
+- [ ] Support for private gem sources
+- [ ] Changelog integration
+- [ ] Security vulnerability detection
+- [ ] Custom update policies
+- [ ] Integration with CI/CD pipelines

data/REQUIREMENTS.md

@@ -0,0 +1,151 @@
+
+### 📁 Exact `gem-digest` Project Structure
+
+```
+gem-digest/
+├── .github/
+│   └── workflows/
+│       └── release.yml
+├── bin/
+│   ├── console
+│   └── gemd
+├── config/
+├── exe/
+│   └── gemd
+├── lib/
+│   ├── gem_digest/
+│   │   ├── analyzer.rb
+│   │   ├── categorizer.rb
+│   │   ├── changelog_fetcher.rb
+│   │   ├── cli.rb
+│   │   ├── reporters/
+│   │   │   ├── base.rb
+│   │   │   ├── console.rb
+│   │   │   └── markdown.rb
+│   │   └── version.rb
+│   └── gem_digest.rb
+├── output/
+├── spec/
+│   ├── gem_digest/
+│   │   ├── analyzer_spec.rb
+│   │   ├── categorizer_spec.rb
+│   │   └── cli_spec.rb
+│   ├── integration_spec.rb
+│   └── spec_helper.rb
+├── .gitignore
+├── .rspec
+├── .rubocop.yml
+├── CHANGELOG.md
+├── Gemfile
+├── LICENSE.txt
+├── Rakefile
+├── README.md
+└── gem-digest.gemspec
+```
+
+### 📚 Key Files and Directories Explained
+
+| **File/Directory** | **Core Purpose** |
+| :--- | :--- |
+| **`exe/gemd`** | Main executable CLI entry point. Uses `#!/usr/bin/env ruby` shebang . |
+| **`lib/gem_digest.rb`** | Primary require file that loads the module . |
+| **`lib/gem_digest/cli.rb`** | Uses the `commander` gem to define commands, options, and help messages . |
+| **`lib/gem_digest/analyzer.rb`** | Parses `Gemfile.lock` (using `Bundler` gem) and fetches latest versions from RubyGems. |
+| **`lib/gem_digest/categorizer.rb`** | Compares versions and categorizes updates by semver (major, minor, patch). |
+| **`lib/gem_digest/reporters/`** | Housedifferent output formats (console, markdown) . |
+| **`gem-digest.gemspec`** | Defines gem metadata, version, and dependencies (e.g., `commander`, `bundler`) . |
+| **`spec/`** | Contains unit and integration tests using RSpec . |
+| **`.github/workflows/release.yml`** | CI/CD workflow to run tests on push and build/release cross-platform gems on tag. |
+
+### ⚙️ Core Components and Requirements
+
+Your `gem-digest.gemspec` file should specify these core dependencies:
+
+```ruby
+spec.add_dependency "bundler", "~> 2.0" # For parsing Gemfile.lock
+spec.add_dependency "commander", "~> 4.5" # For building the CLI structure 
+spec.add_dependency "pastel", "~> 0.8" # For colored console output
+spec.add_dependency "tty-table", "~> 0.12" # For formatted tables in the console
+
+spec.add_development_dependency "rspec", "~> 3.0"
+spec.add_development_dependency "rake", "~> 13.0"
+```
+
+The main executable `exe/gemd` should start with:
+```ruby
+#!/usr/bin/env ruby
+require 'gem_digest'
+require 'commander/import'
+
+# ... CLI program definition using commander
+```
+
+### 🛠️ Development Setup
+
+1.  **Install dependencies locally**: Run `bundle install` to install all required gems.
+2.  **Test during development**: Use `bundle exec ruby -Ilib exe/gemd` to run your tool with the correct load path without installing it . The `bin/console` script can provide an interactive environment for testing methods.
+3.  **Run tests**: Execute `bundle exec rspec` to run your test suite.
+
+### 🚀 Cross-Platform Build & Release via GitHub Actions
+
+Create `.github/workflows/release.yml` to automatically build and release your gem for multiple platforms and Ruby versions. This workflow should:
+
+-   **Trigger on tag pushes** (e.g., `v1.0.0`)
+-   **Run tests** across multiple OS (Ubuntu, macOS, Windows) and Ruby versions
+-   **Build the gem** for each Ruby version
+-   **Create a GitHub Release** and attach all built `.gem` files
+
+```yaml
+name: Build and Release Gem
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    name: Build Gem on ${{ matrix.os }} (Ruby ${{ matrix.ruby }})
+    runs-on: ${{ matrix.os }}-latest
+    strategy:
+      matrix:
+        os: [ubuntu, macos, windows]
+        ruby: ['3.1', '3.2', '3.3']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rspec
+
+      - name: Build Gem
+        run: gem build gem-digest.gemspec
+
+      - name: Upload Gem Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: gem-digest-${{ matrix.os }}-ruby${{ matrix.ruby }}
+          path: "*.gem"
+
+  release:
+    name: Create Release
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all built gems
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: "artifacts/**/*.gem"
+```

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/gemd

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/gem_digest"
+require_relative "../lib/gem_digest/cli"
+
+GemDigest::CLI.start

data/gem-digest.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/gem_digest/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "gem-digest"
+  spec.version = GemDigest::VERSION
+  spec.authors = ["ND-Zyth"]
+  spec.email = ["NuclearDog@zohomail.com"]
+
+  spec.summary = "Analyze and categorize gem updates from Gemfile.lock"
+  spec.description = "A CLI tool that parses Gemfile.lock files, fetches latest gem versions from RubyGems, and categorizes updates by semantic versioning (major, minor, patch)."
+  spec.homepage = "https://github.com/ND-Zyth/gem-digest"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ND-Zyth/gem-digest"
+  spec.metadata["changelog_uri"] = "https://github.com/ND-Zyth/gem-digest/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir["lib/**/*", "exe/*", "*.md", "*.txt", "Rakefile", "*.gemspec"].select { |f| File.file?(f) }
+  spec.bindir = "exe"
+  spec.executables = ["gemd"]
+  spec.require_paths = ["lib"]
+
+  # Core dependencies
+  spec.add_dependency "bundler", "~> 2.0"
+  spec.add_dependency "commander", "~> 4.5"
+  spec.add_dependency "pastel", "~> 0.8"
+  spec.add_dependency "tty-table", "~> 0.12"
+
+  # Development dependencies
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+end

data/lib/gem_digest/analyzer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "net/http"
+require "json"
+require "uri"
+
+module GemDigest
+  class Analyzer
+    def initialize(gemfile_lock_path = "Gemfile.lock")
+      @gemfile_lock_path = gemfile_lock_path
+      raise Error, "Gemfile.lock not found at #{gemfile_lock_path}" unless File.exist?(gemfile_lock_path)
+    end
+
+    def analyze
+      lockfile = Bundler::LockfileParser.new(File.read(@gemfile_lock_path))
+      gems_data = []
+
+      lockfile.specs.each do |spec|
+        latest_version = fetch_latest_version(spec.name)
+        next unless latest_version
+
+        gems_data << {
+          name: spec.name,
+          current_version: spec.version.to_s,
+          latest_version: latest_version,
+          source: spec.source&.to_s || "rubygems"
+        }
+      end
+
+      gems_data
+    end
+
+    private
+
+    def fetch_latest_version(gem_name)
+      uri = URI("https://rubygems.org/api/v1/gems/#{gem_name}.json")
+      
+      begin
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.code == "200"
+        
+        gem_info = JSON.parse(response.body)
+        gem_info["version"]
+      rescue StandardError => e
+        warn "Warning: Could not fetch latest version for #{gem_name}: #{e.message}"
+        nil
+      end
+    end
+  end
+end

data/lib/gem_digest/categorizer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module GemDigest
+  class Categorizer
+    def categorize(gems_data)
+      categorized = {
+        major: [],
+        minor: [],
+        patch: [],
+        up_to_date: []
+      }
+
+      gems_data.each do |gem_data|
+        current = parse_version(gem_data[:current_version])
+        latest = parse_version(gem_data[:latest_version])
+        
+        next unless current && latest
+
+        category = determine_update_category(current, latest)
+        categorized[category] << gem_data
+      end
+
+      categorized
+    end
+
+    private
+
+    def parse_version(version_string)
+      # Handle version strings like "1.2.3", "1.2.3.pre", etc.
+      parts = version_string.split(/[.-]/).map(&:to_i)
+      return nil if parts.empty?
+      
+      # Ensure we have at least 3 parts (major, minor, patch)
+      while parts.length < 3
+        parts << 0
+      end
+      
+      parts[0..2] # Return only major, minor, patch
+    end
+
+    def determine_update_category(current, latest)
+      return :up_to_date if current == latest
+
+      major_current, minor_current, patch_current = current
+      major_latest, minor_latest, patch_latest = latest
+
+      if major_latest > major_current
+        :major
+      elsif minor_latest > minor_current
+        :minor
+      elsif patch_latest > patch_current
+        :patch
+      else
+        :up_to_date
+      end
+    end
+  end
+end

data/lib/gem_digest/changelog_fetcher.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module GemDigest
+  class ChangelogFetcher
+    def initialize
+      @cache = {}
+    end
+
+    def fetch_changelog_url(gem_name)
+      return @cache[gem_name] if @cache.key?(gem_name)
+
+      uri = URI("https://rubygems.org/api/v1/gems/#{gem_name}.json")
+      
+      begin
+        response = Net::HTTP.get_response(uri)
+        return nil unless response.code == "200"
+        
+        gem_info = JSON.parse(response.body)
+        changelog_url = gem_info["changelog_uri"] || 
+                       gem_info["homepage_uri"] || 
+                       gem_info["source_code_uri"]
+        
+        @cache[gem_name] = changelog_url
+        changelog_url
+      rescue StandardError => e
+        warn "Warning: Could not fetch changelog for #{gem_name}: #{e.message}"
+        @cache[gem_name] = nil
+        nil
+      end
+    end
+
+    def fetch_release_notes(gem_name, from_version, to_version)
+      # This is a placeholder for more advanced changelog parsing
+      # In a real implementation, you might parse GitHub releases, CHANGELOG files, etc.
+      changelog_url = fetch_changelog_url(gem_name)
+      return nil unless changelog_url
+
+      {
+        gem_name: gem_name,
+        from_version: from_version,
+        to_version: to_version,
+        changelog_url: changelog_url,
+        notes: "See changelog for details about changes from #{from_version} to #{to_version}"
+      }
+    end
+  end
+end

data/lib/gem_digest/cli.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "commander/import"
+require_relative "../gem_digest"
+
+module GemDigest
+  class CLI
+    def self.start
+      program :name, "gemd"
+      program :version, GemDigest::VERSION
+      program :description, "Analyze and categorize gem updates from Gemfile.lock"
+
+      command :analyze do |c|
+        c.syntax = "gemd analyze [options]"
+        c.summary = "Analyze Gemfile.lock and show available gem updates"
+        c.description = "Parse Gemfile.lock, fetch latest versions from RubyGems, and categorize updates by semantic versioning"
+        
+        c.option "--gemfile-lock PATH", String, "Path to Gemfile.lock (default: ./Gemfile.lock)"
+        c.option "--format FORMAT", String, "Output format: console or markdown (default: console)"
+        c.option "--output-dir DIR", String, "Output directory for reports (default: ./output)"
+        c.option "--show-up-to-date", "Show gems that are already up to date"
+        c.option "--verbose", "Show detailed output"
+
+        c.action do |args, options|
+          options.default(
+            gemfile_lock: "Gemfile.lock",
+            format: "console",
+            output_dir: "output",
+            show_up_to_date: false,
+            verbose: false
+          )
+
+          begin
+            puts "🔍 Analyzing gems..." if options.verbose
+            
+            analyzer = GemDigest::Analyzer.new(options.gemfile_lock)
+            gems_data = analyzer.analyze
+            
+            puts "📊 Categorizing updates..." if options.verbose
+            
+            categorizer = GemDigest::Categorizer.new
+            categorized_gems = categorizer.categorize(gems_data)
+            
+            puts "📝 Generating report..." if options.verbose
+            
+            reporter_class = case options.format
+                            when "markdown"
+                              GemDigest::Reporters::Markdown
+                            else
+                              GemDigest::Reporters::Console
+                            end
+            
+            reporter_options = {
+              output_dir: options.output_dir,
+              show_up_to_date: options.show_up_to_date,
+              verbose: options.verbose
+            }
+            
+            reporter = reporter_class.new(reporter_options)
+            reporter.generate_report(categorized_gems)
+            
+          rescue GemDigest::Error => e
+            puts "❌ Error: #{e.message}"
+            exit 1
+          rescue StandardError => e
+            puts "❌ Unexpected error: #{e.message}"
+            puts e.backtrace if options.verbose
+            exit 1
+          end
+        end
+      end
+
+      command :version do |c|
+        c.syntax = "gemd version"
+        c.summary = "Show gem-digest version"
+        c.action do
+          puts "gem-digest version #{GemDigest::VERSION}"
+        end
+      end
+
+      default_command :analyze
+    end
+  end
+end

data/lib/gem_digest/reporters/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GemDigest
+  module Reporters
+    class Base
+      def initialize(options = {})
+        @options = options
+        @output_dir = options[:output_dir] || "output"
+        ensure_output_directory
+      end
+
+      def generate_report(categorized_gems)
+        raise NotImplementedError, "Subclasses must implement generate_report"
+      end
+
+      protected
+
+      def ensure_output_directory
+        Dir.mkdir(@output_dir) unless Dir.exist?(@output_dir)
+      end
+
+      def count_updates(categorized_gems)
+        {
+          major: categorized_gems[:major].length,
+          minor: categorized_gems[:minor].length,
+          patch: categorized_gems[:patch].length,
+          up_to_date: categorized_gems[:up_to_date].length
+        }
+      end
+
+      def total_gems(categorized_gems)
+        categorized_gems.values.flatten.length
+      end
+    end
+  end
+end

data/lib/gem_digest/reporters/console.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-table"
+
+module GemDigest
+  module Reporters
+    class Console < Base
+      def initialize(options = {})
+        super
+        @pastel = Pastel.new
+      end
+
+      def generate_report(categorized_gems)
+        print_summary(categorized_gems)
+        print_category_tables(categorized_gems)
+      end
+
+      private
+
+      def print_summary(categorized_gems)
+        counts = count_updates(categorized_gems)
+        total = total_gems(categorized_gems)
+
+        puts @pastel.bold.cyan("\n🔍 Gem Digest Analysis Summary")
+        puts @pastel.dim("=" * 50)
+        
+        puts "📦 Total gems analyzed: #{@pastel.bold(total)}"
+        puts "🔴 Major updates available: #{@pastel.red.bold(counts[:major])}"
+        puts "🟡 Minor updates available: #{@pastel.yellow.bold(counts[:minor])}"
+        puts "🟢 Patch updates available: #{@pastel.green.bold(counts[:patch])}"
+        puts "✅ Up to date: #{@pastel.dim(counts[:up_to_date])}"
+        puts
+      end
+
+      def print_category_tables(categorized_gems)
+        print_category("Major Updates", categorized_gems[:major], :red) if categorized_gems[:major].any?
+        print_category("Minor Updates", categorized_gems[:minor], :yellow) if categorized_gems[:minor].any?
+        print_category("Patch Updates", categorized_gems[:patch], :green) if categorized_gems[:patch].any?
+        
+        if @options[:show_up_to_date] && categorized_gems[:up_to_date].any?
+          print_category("Up to Date", categorized_gems[:up_to_date], :dim)
+        end
+      end
+
+      def print_category(title, gems, color)
+        return if gems.empty?
+
+        puts @pastel.bold.send(color, "#{title} (#{gems.length})")
+        puts @pastel.dim("-" * (title.length + gems.length.to_s.length + 3))
+
+        table = TTY::Table.new(header: ["Gem", "Current", "Latest", "Source"])
+        
+        gems.each do |gem_data|
+          table << [
+            gem_data[:name],
+            gem_data[:current_version],
+            gem_data[:latest_version],
+            format_source(gem_data[:source])
+          ]
+        end
+
+        puts table.render(:unicode, padding: [0, 1])
+        puts
+      end
+
+      def format_source(source)
+        return "rubygems" if source.nil? || source.empty? || source.include?("rubygems")
+        
+        if source.include?("git")
+          "git"
+        elsif source.include?("path")
+          "local"
+        else
+          "other"
+        end
+      end
+    end
+  end
+end

data/lib/gem_digest/reporters/markdown.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module GemDigest
+  module Reporters
+    class Markdown < Base
+      def generate_report(categorized_gems)
+        content = build_markdown_content(categorized_gems)
+        output_file = File.join(@output_dir, "gem-digest-report.md")
+        
+        File.write(output_file, content)
+        puts "📄 Markdown report generated: #{output_file}"
+      end
+
+      private
+
+      def build_markdown_content(categorized_gems)
+        content = []
+        content << "# 💎 Gem Digest Report"
+        content << ""
+        content << "Generated on: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+        content << ""
+        
+        content << build_summary_section(categorized_gems)
+        content << build_details_section(categorized_gems)
+        
+        content.join("\n")
+      end
+
+      def build_summary_section(categorized_gems)
+        counts = count_updates(categorized_gems)
+        total = total_gems(categorized_gems)
+
+        summary = []
+        summary << "## 📊 Summary"
+        summary << ""
+        summary << "| Category | Count |"
+        summary << "|----------|-------|"
+        summary << "| 📦 Total gems | #{total} |"
+        summary << "| 🔴 Major updates | #{counts[:major]} |"
+        summary << "| 🟡 Minor updates | #{counts[:minor]} |"
+        summary << "| 🟢 Patch updates | #{counts[:patch]} |"
+        summary << "| ✅ Up to date | #{counts[:up_to_date]} |"
+        summary << ""
+        
+        summary.join("\n")
+      end
+
+      def build_details_section(categorized_gems)
+        details = []
+        details << "## 📋 Detailed Analysis"
+        details << ""
+
+        if categorized_gems[:major].any?
+          details << build_category_section("🔴 Major Updates", categorized_gems[:major])
+        end
+
+        if categorized_gems[:minor].any?
+          details << build_category_section("🟡 Minor Updates", categorized_gems[:minor])
+        end
+
+        if categorized_gems[:patch].any?
+          details << build_category_section("🟢 Patch Updates", categorized_gems[:patch])
+        end
+
+        if @options[:show_up_to_date] && categorized_gems[:up_to_date].any?
+          details << build_category_section("✅ Up to Date", categorized_gems[:up_to_date])
+        end
+
+        details.join("\n")
+      end
+
+      def build_category_section(title, gems)
+        return "" if gems.empty?
+
+        section = []
+        section << "### #{title}"
+        section << ""
+        section << "| Gem | Current Version | Latest Version | Source |"
+        section << "|-----|-----------------|----------------|--------|"
+        
+        gems.each do |gem_data|
+          section << "| #{gem_data[:name]} | #{gem_data[:current_version]} | #{gem_data[:latest_version]} | #{format_source(gem_data[:source])} |"
+        end
+        
+        section << ""
+        section.join("\n")
+      end
+
+      def format_source(source)
+        return "RubyGems" if source.nil? || source.empty? || source.include?("rubygems")
+        
+        if source.include?("git")
+          "Git"
+        elsif source.include?("path")
+          "Local"
+        else
+          "Other"
+        end
+      end
+    end
+  end
+end

data/lib/gem_digest/version.rb

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

data/lib/gem_digest.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "gem_digest/version"
+require_relative "gem_digest/analyzer"
+require_relative "gem_digest/categorizer"
+require_relative "gem_digest/changelog_fetcher"
+require_relative "gem_digest/cli"
+require_relative "gem_digest/reporters/base"
+require_relative "gem_digest/reporters/console"
+require_relative "gem_digest/reporters/markdown"
+
+module GemDigest
+  class Error < StandardError; end
+
+  def self.analyze(gemfile_lock_path = "Gemfile.lock", options = {})
+    analyzer = Analyzer.new(gemfile_lock_path)
+    gems_data = analyzer.analyze
+    
+    categorizer = Categorizer.new
+    categorized_gems = categorizer.categorize(gems_data)
+    
+    reporter_class = case options[:format]
+                    when "markdown"
+                      Reporters::Markdown
+                    else
+                      Reporters::Console
+                    end
+    
+    reporter = reporter_class.new(options)
+    reporter.generate_report(categorized_gems)
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: gem-digest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ND-Zyth
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: A CLI tool that parses Gemfile.lock files, fetches latest gem versions
+  from RubyGems, and categorizes updates by semantic versioning (major, minor, patch).
+email:
+- NuclearDog@zohomail.com
+executables:
+- gemd
+extensions: []
+extra_rdoc_files: []
+files:
+- DEVELOPMENT.md
+- LICENSE.txt
+- README.md
+- REQUIREMENTS.md
+- Rakefile
+- exe/gemd
+- gem-digest.gemspec
+- lib/gem_digest.rb
+- lib/gem_digest/analyzer.rb
+- lib/gem_digest/categorizer.rb
+- lib/gem_digest/changelog_fetcher.rb
+- lib/gem_digest/cli.rb
+- lib/gem_digest/reporters/base.rb
+- lib/gem_digest/reporters/console.rb
+- lib/gem_digest/reporters/markdown.rb
+- lib/gem_digest/version.rb
+homepage: https://github.com/ND-Zyth/gem-digest
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ND-Zyth/gem-digest
+  source_code_uri: https://github.com/ND-Zyth/gem-digest
+  changelog_uri: https://github.com/ND-Zyth/gem-digest/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Analyze and categorize gem updates from Gemfile.lock
+test_files: []