gemkeeper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45860b370cd7f5370ab01069c44b9547208b64b0de895e1e2e1f625d87873fec
+  data.tar.gz: 1989d795d04f3d368e5e26c419b6e8d10c59a2ae814a2d9cb28c1083d5cbf081
+SHA512:
+  metadata.gz: 9e9ef5c779e1b6928562fbb39277f605aede5f46dc3d2d6937951b926a5fc296f2d530ffb5417548ab6155586e15a2e4eba990ad369fd7a2ec983999fb070bd5
+  data.tar.gz: b83947d19960c2439d7abcb49b4aa64113c1d5333bb133ab63cf6ce71d81d62ca403145c752545c1f58e02ebfcfc6f14ff92eba03903192e1b6d321136a0fe97

data/.env.example

@@ -0,0 +1 @@
+RUBYGEMS_PROXY=true

data/.envrc

@@ -0,0 +1,3 @@
+dotenv
+
+PATH_add bin

data/.rubocop.yml

@@ -0,0 +1,30 @@
+plugins:
+  - rubocop-performance
+
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - cache/**/*
+    - vendor/**/*
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 30
+
+Metrics/AbcSize:
+  Max: 40
+
+Metrics/ClassLength:
+  Max: 120
+  Exclude:
+    - test/**/*

data/AGENTS.md

@@ -0,0 +1,52 @@
+# Gemkeeper
+
+A Ruby CLI tool for managing offline development with private gem dependencies.
+
+## Purpose
+
+Automate building internal gems from source and caching them in a local Geminabox server for offline Rails development when disconnected from VPN.
+
+## Architecture
+
+- Ruby gem with CLI executable (`exe/gemkeeper`)
+- YAML config for gem repository definitions
+- Git operations to clone/pull internal repos
+- Build gems at specified versions/tags
+- Upload to local Geminabox server
+- Geminabox proxies public gems from RubyGems.org
+
+## Config Example
+
+```yaml
+port: 9292
+repos_path: ./cache/repos
+gems_path: ./cache/gems
+
+gems:
+  - repo: git@github.com:company/internal-gem-1.git
+    version: latest
+  - repo: git@github.com:company/internal-gem-2.git
+    version: v2.3.1
+```
+
+## CLI Commands
+
+- `gemkeeper version` - Print version
+- `gemkeeper server start` - Start Geminabox server
+- `gemkeeper server stop` - Stop Geminabox server
+- `gemkeeper server status` - Check server status
+- `gemkeeper sync` - Build and upload all configured gems
+- `gemkeeper sync <gem-name>` - Sync specific gem
+- `gemkeeper list` - Show locally uploaded gems
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test    # Run tests
+bundle exec rubocop      # Run linter
+```
+
+## Current Status
+
+v1 complete - all core functionality implemented

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-01-29
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE

@@ -0,0 +1,5 @@
+Copyright 2026 Dan Brubaker Horst
+
+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.
+
+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/Makefile

@@ -0,0 +1,26 @@
+.PHONY: all build test fmt clean
+
+# Find all tool directories under cmd/
+TOOLS := $(wildcard cmd/*)
+BINARIES := $(notdir $(TOOLS))
+
+all: build
+
+build:
+	@for tool in $(BINARIES); do \
+		if [ -d "cmd/$$tool" ] && [ -f "cmd/$$tool/main.go" ]; then \
+			echo "Building $$tool..."; \
+			go build -o bin/$$tool ./cmd/$$tool; \
+		fi \
+	done
+
+test:
+	go test .
+
+fmt:
+	gofmt -w .
+
+clean:
+	rm -f bin/*
+	@# Preserve agent-setup script
+	@git checkout bin/agent-setup 2>/dev/null || true

data/README.md

@@ -0,0 +1,19 @@
+# Gemkeeper
+
+An opinionated wrapper around [Gem in a Box][1] for local, sandboxed Ruby development.
+
+## Usage
+
+This project can be run directly on your machine or in a Docker container.
+For a local service, you'll need to install [Ruby][2], ideally with a [version manager][3].
+
+## Colophon
+
+This project has been augmented with [Claude Code][4].
+The instructions for all agents are all in `AGENTS.md`.
+There is a utility script (`bin/agent-setup`) that takes care of symlinking `AGENTS.md` to `CLAUDE.md`.
+
+[1]: https://github.com/geminabox/geminabox
+[2]: https://www.ruby-lang.org/en/
+[3]: https://www.ruby-lang.org/en/documentation/installation/#managers
+[4]: https://claude.com/product/claude-code

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/exe/gemkeeper

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "gemkeeper"
+require "gemkeeper/cli"
+
+Dry::CLI.new(Gemkeeper::CLI).call

data/gemkeeper.yml.example

@@ -0,0 +1,26 @@
+# Gemkeeper configuration file
+# Copy this to gemkeeper.yml and modify as needed
+
+# Server port (default: 9292)
+port: 9292
+
+# Path for cloned repositories (default: ./cache/repos)
+repos_path: ./cache/repos
+
+# Path for Geminabox gem storage (default: ./cache/gems)
+gems_path: ./cache/gems
+
+# List of internal gems to sync
+gems:
+  # Sync the latest version from the main/master branch
+  - repo: git@github.com:company/internal-gem.git
+    version: latest
+
+  # Sync a specific tag or branch
+  - repo: git@github.com:company/another-gem.git
+    version: v2.3.1
+
+  # Override the gem name if it differs from the repo name
+  - repo: git@github.com:company/ruby-mylib.git
+    name: mylib
+    version: latest

data/lib/gemkeeper/cli/commands/list.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      class List < Dry::CLI::Command
+        desc "List gems cached in Geminabox"
+
+        option :config, type: :string, desc: "Path to config file"
+
+        def call(**options)
+          config = Configuration.load(options[:config])
+
+          gem_files = Dir.glob(File.join(config.gems_path, "gems", "*.gem"))
+
+          if gem_files.empty?
+            puts "No gems cached in Geminabox"
+            puts "  Gems directory: #{config.gems_path}"
+            return
+          end
+
+          puts "Cached gems:"
+          gem_files.sort.each do |gem_file|
+            gem_name = File.basename(gem_file, ".gem")
+            puts "  #{gem_name}"
+          end
+        end
+      end
+    end
+
+    register "list", Commands::List
+  end
+end

data/lib/gemkeeper/cli/commands/server/start.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      module Server
+        class Start < Dry::CLI::Command
+          desc "Start the Geminabox server"
+
+          option :port, type: :integer, desc: "Port to run server on"
+          option :config, type: :string, desc: "Path to config file"
+          option :foreground, type: :boolean, default: false, aliases: ["-f"],
+                              desc: "Run in foreground (don't daemonize)"
+
+          def call(**options)
+            config = Configuration.load(options[:config])
+            config = override_port(config, options[:port]) if options[:port]
+
+            manager = ServerManager.new(config)
+
+            if options[:foreground]
+              puts "Starting Geminabox server at #{config.geminabox_url}"
+              puts "Press Ctrl+C to stop"
+              manager.start_foreground
+            else
+              manager.start
+              puts "Geminabox server started at #{config.geminabox_url}"
+              puts "PID: #{File.read(config.pid_file).strip}"
+            end
+          rescue ServerAlreadyRunningError => e
+            warn "Error: #{e.message}"
+            exit 1
+          rescue ServerError => e
+            warn "Error starting server: #{e.message}"
+            exit 1
+          rescue Interrupt
+            puts "\nShutting down..."
+          end
+
+          private
+
+          def override_port(config, port)
+            config.instance_variable_set(:@port, port)
+            config
+          end
+        end
+      end
+    end
+
+    register "server start", Commands::Server::Start
+  end
+end

data/lib/gemkeeper/cli/commands/server/status.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      module Server
+        class Status < Dry::CLI::Command
+          desc "Check Geminabox server status"
+
+          option :config, type: :string, desc: "Path to config file"
+
+          def call(**options)
+            config = Configuration.load(options[:config])
+            manager = ServerManager.new(config)
+            status = manager.status
+
+            if status[:running]
+              puts "Geminabox server is running"
+              puts "  PID: #{status[:pid]}"
+              puts "  URL: #{status[:url]}"
+            else
+              puts "Geminabox server is not running"
+            end
+          end
+        end
+      end
+    end
+
+    register "server status", Commands::Server::Status
+  end
+end

data/lib/gemkeeper/cli/commands/server/stop.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      module Server
+        class Stop < Dry::CLI::Command
+          desc "Stop the Geminabox server"
+
+          option :config, type: :string, desc: "Path to config file"
+
+          def call(**options)
+            config = Configuration.load(options[:config])
+            manager = ServerManager.new(config)
+            manager.stop
+
+            puts "Geminabox server stopped"
+          rescue ServerNotRunningError => e
+            warn "Error: #{e.message}"
+            exit 1
+          rescue ServerError => e
+            warn "Error stopping server: #{e.message}"
+            exit 1
+          end
+        end
+      end
+    end
+
+    register "server stop", Commands::Server::Stop
+  end
+end

data/lib/gemkeeper/cli/commands/sync.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      class Sync < Dry::CLI::Command
+        desc "Sync gems from configured repositories"
+
+        argument :gem_name, type: :string, required: false, desc: "Specific gem to sync"
+        option :config, type: :string, desc: "Path to config file"
+
+        def call(gem_name: nil, **options)
+          config = Configuration.load(options[:config])
+
+          if config.gems.empty?
+            warn "No gems configured. Add gems to your gemkeeper.yml file."
+            exit 1
+          end
+
+          gems_to_sync = if gem_name
+                           config.gems.select { |g| g.name == gem_name }
+                         else
+                           config.gems
+                         end
+
+          if gems_to_sync.empty?
+            warn "No matching gem found: #{gem_name}"
+            exit 1
+          end
+
+          uploader = GemUploader.new(config.geminabox_url)
+
+          gems_to_sync.each do |gem_def|
+            sync_gem(gem_def, config, uploader)
+          end
+        rescue Error => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+        private
+
+        def sync_gem(gem_def, config, uploader)
+          puts "Syncing #{gem_def.name}..."
+
+          # Clone or pull the repository
+          local_path = File.join(config.repos_path, gem_def.name)
+          repo = GitRepository.new(gem_def.repo, local_path)
+
+          puts "  Fetching from #{gem_def.repo}..."
+          repo.clone_or_pull
+
+          # Checkout the specified version
+          puts "  Checking out #{gem_def.version}..."
+          repo.checkout_version(gem_def.version)
+
+          # Build the gem
+          puts "  Building gem..."
+          builder = GemBuilder.new(local_path)
+          gem_path = builder.build
+
+          # Upload to Geminabox
+          puts "  Uploading to Geminabox..."
+          result = uploader.upload(gem_path)
+
+          puts "  #{result[:message]}"
+
+          # Clean up the built gem file
+          FileUtils.rm_f(gem_path)
+
+          puts "  Done!"
+        rescue GitError => e
+          warn "  Git error: #{e.message}"
+          raise
+        rescue BuildError => e
+          warn "  Build error: #{e.message}"
+          raise
+        rescue UploadError => e
+          warn "  Upload error: #{e.message}"
+          raise
+        end
+      end
+    end
+
+    register "sync", Commands::Sync
+  end
+end

data/lib/gemkeeper/cli/commands/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      class Version < Dry::CLI::Command
+        desc "Print version"
+
+        def call(*)
+          puts "gemkeeper #{Gemkeeper::VERSION}"
+        end
+      end
+    end
+
+    register "version", Commands::Version, aliases: ["-v", "--version"]
+  end
+end

data/lib/gemkeeper/cli.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+module Gemkeeper
+  module CLI
+    extend Dry::CLI::Registry
+
+    module Commands
+      extend Dry::CLI::Registry
+    end
+  end
+end
+
+require_relative "cli/commands/version"
+require_relative "cli/commands/sync"
+require_relative "cli/commands/list"
+require_relative "cli/commands/server/start"
+require_relative "cli/commands/server/stop"
+require_relative "cli/commands/server/status"

data/lib/gemkeeper/configuration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Gemkeeper
+  class Configuration
+    DEFAULT_PORT = 9292
+    DEFAULT_CONFIG_FILENAME = "gemkeeper.yml"
+
+    # Config file lookup paths in order of priority
+    CONFIG_PATHS = [
+      -> { File.join(Dir.pwd, DEFAULT_CONFIG_FILENAME) },              # ./gemkeeper.yml
+      -> { File.expand_path("~/.config/gemkeeper/config.yml") },       # XDG config
+      -> { File.expand_path("~/.gemkeeper.yml") },                     # Home directory
+      -> { "/usr/local/etc/gemkeeper.yml" },                           # Homebrew (Intel)
+      -> { "/opt/homebrew/etc/gemkeeper.yml" }                         # Homebrew (Apple Silicon)
+    ].freeze
+
+    attr_reader :port, :repos_path, :gems_path, :pid_file, :gems
+
+    def self.load(config_path = nil)
+      new(config_path)
+    end
+
+    def self.config_search_paths
+      CONFIG_PATHS.map { |p| p.is_a?(Proc) ? p.call : p }
+    end
+
+    def initialize(config_path = nil)
+      @config_path = config_path || find_config_file
+      @config = load_config
+      apply_config
+    end
+
+    def geminabox_url
+      "http://localhost:#{port}"
+    end
+
+    def config_ru_path
+      File.join(cache_dir, "config.ru")
+    end
+
+    def cache_dir
+      @cache_dir ||= begin
+        dir = File.expand_path("./cache")
+        FileUtils.mkdir_p(dir)
+        dir
+      end
+    end
+
+    private
+
+    def find_config_file
+      self.class.config_search_paths.find { |path| File.exist?(path) }
+    end
+
+    def load_config
+      return {} unless @config_path && File.exist?(@config_path)
+
+      begin
+        YAML.safe_load_file(@config_path, permitted_classes: [], symbolize_names: true) || {}
+      rescue Psych::SyntaxError => e
+        raise InvalidConfigError, "Invalid YAML in #{@config_path}: #{e.message}"
+      end
+    end
+
+    def apply_config
+      @port = @config.fetch(:port, DEFAULT_PORT)
+      @repos_path = File.expand_path(@config.fetch(:repos_path, "./cache/repos"))
+      @gems_path = File.expand_path(@config.fetch(:gems_path, "./cache/gems"))
+      @pid_file = File.expand_path(@config.fetch(:pid_file, "./cache/gemkeeper.pid"))
+      @gems = (@config[:gems] || []).map { |g| GemDefinition.new(g) }
+
+      FileUtils.mkdir_p(@repos_path)
+      FileUtils.mkdir_p(@gems_path)
+    end
+
+    class GemDefinition
+      attr_reader :repo, :version, :name
+
+      def initialize(config)
+        @repo = config[:repo] or raise InvalidConfigError, "Gem definition missing 'repo'"
+        @version = config[:version] || "latest"
+        @name = config[:name] || extract_name_from_repo
+      end
+
+      def latest?
+        @version == "latest"
+      end
+
+      private
+
+      def extract_name_from_repo
+        File.basename(@repo, ".git").sub(/^ruby-/, "")
+      end
+    end
+  end
+end

data/lib/gemkeeper/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+  class ConfigFileNotFoundError < ConfigurationError; end
+  class InvalidConfigError < ConfigurationError; end
+
+  class GitError < Error; end
+  class CloneError < GitError; end
+  class CheckoutError < GitError; end
+
+  class BuildError < Error; end
+  class GemspecNotFoundError < BuildError; end
+
+  class UploadError < Error; end
+
+  class ServerError < Error; end
+  class ServerAlreadyRunningError < ServerError; end
+  class ServerNotRunningError < ServerError; end
+end

data/lib/gemkeeper/gem_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Gemkeeper
+  class GemBuilder
+    attr_reader :repo_path, :output_dir
+
+    def initialize(repo_path, output_dir = nil)
+      @repo_path = repo_path
+      @output_dir = output_dir
+    end
+
+    def build
+      gemspec_path = find_gemspec
+      raise GemspecNotFoundError, "No gemspec found in #{@repo_path}" unless gemspec_path
+
+      Dir.chdir(@repo_path) do
+        gem_file = run_gem_build(gemspec_path)
+        gem_path = File.join(@repo_path, gem_file)
+
+        if @output_dir
+          FileUtils.mkdir_p(@output_dir)
+          dest_path = File.join(@output_dir, gem_file)
+          FileUtils.mv(gem_path, dest_path)
+          dest_path
+        else
+          gem_path
+        end
+      end
+    end
+
+    def gem_name
+      gemspec_path = find_gemspec
+      return nil unless gemspec_path
+
+      File.basename(gemspec_path, ".gemspec")
+    end
+
+    private
+
+    def find_gemspec
+      Dir.glob(File.join(@repo_path, "*.gemspec")).first
+    end
+
+    def run_gem_build(gemspec_path)
+      stdout, stderr, status = Open3.capture3("gem", "build", gemspec_path)
+
+      raise BuildError, "Gem build failed:\n#{stderr}" unless status.success?
+
+      # Parse the output to find the generated gem file
+      unless stdout =~ /File:\s+(\S+\.gem)/
+        raise BuildError, "Could not determine built gem file from output:\n#{stdout}"
+      end
+
+      Regexp.last_match(1)
+    end
+  end
+end

data/lib/gemkeeper/gem_uploader.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+
+module Gemkeeper
+  class GemUploader
+    attr_reader :geminabox_url
+
+    def initialize(geminabox_url)
+      @geminabox_url = geminabox_url
+    end
+
+    def upload(gem_path)
+      raise UploadError, "Gem file not found: #{gem_path}" unless File.exist?(gem_path)
+
+      response = connection.post("/upload") do |req|
+        req.body = {
+          file: Faraday::Multipart::FilePart.new(
+            gem_path,
+            "application/octet-stream",
+            File.basename(gem_path)
+          )
+        }
+      end
+
+      handle_response(response, gem_path)
+    end
+
+    def list_gems
+      response = connection.get("/api/v1/gems.json")
+
+      raise UploadError, "Failed to list gems: #{response.status} #{response.body}" unless response.success?
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError => e
+      raise UploadError, "Invalid JSON response: #{e.message}"
+    rescue Faraday::Error => e
+      raise UploadError, "Connection error: #{e.message}"
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: @geminabox_url) do |f|
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday::Adapter::NetHttp
+      end
+    end
+
+    def handle_response(response, gem_path)
+      case response.status
+      when 200, 201, 302
+        { success: true, message: "Uploaded #{File.basename(gem_path)}" }
+      when 409
+        { success: true, message: "#{File.basename(gem_path)} already exists", skipped: true }
+      else
+        raise UploadError, "Upload failed (#{response.status}): #{response.body}"
+      end
+    rescue Faraday::Error => e
+      raise UploadError, "Connection error: #{e.message}"
+    end
+  end
+end

data/lib/gemkeeper/git_repository.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Gemkeeper
+  class GitRepository
+    attr_reader :repo_url, :local_path
+
+    def initialize(repo_url, local_path)
+      @repo_url = repo_url
+      @local_path = local_path
+    end
+
+    def clone_or_pull
+      if File.directory?(File.join(@local_path, ".git"))
+        pull
+      else
+        clone
+      end
+    end
+
+    def checkout_version(version)
+      if version == "latest"
+        checkout_trunk
+      else
+        checkout_ref(version)
+      end
+    end
+
+    def current_version
+      gemspec_path = find_gemspec
+      return nil unless gemspec_path
+
+      content = File.read(gemspec_path)
+      version_patterns = [
+        /\.version\s*=\s*["']([^"']+)["']/,
+        /VERSION\s*=\s*["']([^"']+)["']/
+      ]
+
+      version_patterns.each do |pattern|
+        return Regexp.last_match(1) if content =~ pattern
+      end
+      nil
+    end
+
+    def find_gemspec
+      Dir.glob(File.join(@local_path, "*.gemspec")).first
+    end
+
+    private
+
+    def clone
+      FileUtils.mkdir_p(File.dirname(@local_path))
+      run_git("clone", @repo_url, @local_path)
+    end
+
+    def pull
+      Dir.chdir(@local_path) do
+        run_git("fetch", "--all", "--tags")
+        trunk = detect_trunk_branch
+        run_git("checkout", trunk)
+        run_git("pull", "origin", trunk)
+      end
+    end
+
+    def checkout_trunk
+      Dir.chdir(@local_path) do
+        trunk = detect_trunk_branch
+        run_git("checkout", trunk)
+        run_git("pull", "origin", trunk)
+      end
+    end
+
+    def checkout_ref(ref)
+      Dir.chdir(@local_path) do
+        run_git("fetch", "--all", "--tags")
+        run_git("checkout", ref)
+      end
+    end
+
+    def detect_trunk_branch
+      Dir.chdir(@local_path) do
+        stdout, = run_git("branch", "-r")
+        remotes = stdout.lines.map(&:strip)
+
+        if remotes.any? { |r| r =~ %r{origin/main$} }
+          "main"
+        elsif remotes.any? { |r| r =~ %r{origin/master$} }
+          "master"
+        else
+          raise GitError, "Cannot detect trunk branch (no main or master found)"
+        end
+      end
+    end
+
+    def run_git(*args)
+      cmd = ["git"] + args
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      raise GitError, "Git command failed: #{cmd.join(" ")}\n#{stderr}" unless status.success?
+
+      [stdout, stderr]
+    end
+  end
+end

data/lib/gemkeeper/server_manager.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Gemkeeper
+  class ServerManager
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def start
+      raise ServerAlreadyRunningError, "Server is already running (PID: #{read_pid})" if running?
+
+      generate_config_ru
+      start_server
+    end
+
+    def start_foreground
+      raise ServerAlreadyRunningError, "Server is already running (PID: #{read_pid})" if running?
+
+      generate_config_ru
+      start_server_foreground
+    end
+
+    def stop
+      raise ServerNotRunningError, "Server is not running" unless running?
+
+      pid = read_pid
+      Process.kill("TERM", pid)
+
+      # Wait for process to stop
+      10.times do
+        break unless process_alive?(pid)
+
+        sleep 0.5
+      end
+
+      # Force kill if still running
+      Process.kill("KILL", pid) if process_alive?(pid)
+
+      cleanup_pid_file
+      true
+    rescue Errno::ESRCH
+      # Process already dead
+      cleanup_pid_file
+      true
+    end
+
+    def status
+      if running?
+        { running: true, pid: read_pid, url: config.geminabox_url }
+      else
+        { running: false }
+      end
+    end
+
+    def running?
+      return false unless File.exist?(config.pid_file)
+
+      pid = read_pid
+      return false unless pid
+
+      process_alive?(pid)
+    end
+
+    private
+
+    def generate_config_ru
+      FileUtils.mkdir_p(config.cache_dir)
+      FileUtils.mkdir_p(config.gems_path)
+
+      content = <<~RUBY
+        # frozen_string_literal: true
+        # Auto-generated by Gemkeeper
+
+        require "rubygems/indexer"
+        require "geminabox"
+
+        Geminabox.data = #{config.gems_path.inspect}
+        Geminabox.rubygems_proxy = true
+
+        run Geminabox::Server
+      RUBY
+
+      File.write(config.config_ru_path, content)
+    end
+
+    def start_server
+      cmd = [
+        "rackup",
+        config.config_ru_path,
+        "-p", config.port.to_s,
+        "-D",
+        "-P", config.pid_file,
+        "-s", "puma"
+      ]
+
+      Dir.chdir(config.cache_dir) do
+        _stdout, stderr, status = Open3.capture3(*cmd)
+
+        raise ServerError, "Failed to start server:\n#{stderr}" unless status.success? || File.exist?(config.pid_file)
+      end
+
+      # Wait for server to be ready
+      wait_for_server
+    end
+
+    def start_server_foreground
+      cmd = [
+        "rackup",
+        config.config_ru_path,
+        "-p", config.port.to_s,
+        "-s", "puma"
+      ]
+
+      Dir.chdir(config.cache_dir) do
+        system(*cmd)
+      end
+    end
+
+    def wait_for_server(timeout: 10)
+      require "net/http"
+
+      deadline = Time.now + timeout
+      uri = URI(config.geminabox_url)
+
+      while Time.now < deadline
+        begin
+          response = Net::HTTP.get_response(uri)
+          return true if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, SocketError
+          # Server not ready yet
+        end
+        sleep 0.5
+      end
+
+      raise ServerError, "Server failed to start within #{timeout} seconds"
+    end
+
+    def read_pid
+      return nil unless File.exist?(config.pid_file)
+
+      pid = File.read(config.pid_file).strip.to_i
+      pid.positive? ? pid : nil
+    end
+
+    def process_alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    def cleanup_pid_file
+      FileUtils.rm_f(config.pid_file)
+    end
+  end
+end

data/lib/gemkeeper/version.rb

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

data/lib/gemkeeper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "gemkeeper/version"
+require_relative "gemkeeper/errors"
+require_relative "gemkeeper/configuration"
+require_relative "gemkeeper/git_repository"
+require_relative "gemkeeper/gem_builder"
+require_relative "gemkeeper/gem_uploader"
+require_relative "gemkeeper/server_manager"
+
+module Gemkeeper
+end

data/sig/gemkeeper.rbs

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

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: gemkeeper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dan Brubaker Horst
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: geminabox
+  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: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: An opinionated wrapper around Gem in a Box to manage private gems in
+  a development environment.
+email:
+- dan.brubaker.horst@gmail.com
+executables:
+- gemkeeper
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.example"
+- ".envrc"
+- ".rubocop.yml"
+- AGENTS.md
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- exe/gemkeeper
+- gemkeeper.yml.example
+- lib/gemkeeper.rb
+- lib/gemkeeper/cli.rb
+- lib/gemkeeper/cli/commands/list.rb
+- lib/gemkeeper/cli/commands/server/start.rb
+- lib/gemkeeper/cli/commands/server/status.rb
+- lib/gemkeeper/cli/commands/server/stop.rb
+- lib/gemkeeper/cli/commands/sync.rb
+- lib/gemkeeper/cli/commands/version.rb
+- lib/gemkeeper/configuration.rb
+- lib/gemkeeper/errors.rb
+- lib/gemkeeper/gem_builder.rb
+- lib/gemkeeper/gem_uploader.rb
+- lib/gemkeeper/git_repository.rb
+- lib/gemkeeper/server_manager.rb
+- lib/gemkeeper/version.rb
+- sig/gemkeeper.rbs
+homepage: https://github.com/danhorst/gemkeeper
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/danhorst/gemkeeper
+  source_code_uri: https://github.com/danhorst/gemkeeper
+  changelog_uri: https://github.com/danhorst/gemkeeper/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+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.6.8
+specification_version: 4
+summary: Manage offline development with private gem dependencies
+test_files: []