gemkeeper 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a97b09f4efb6325d8efdb7f33130bdf0f2e999c647b68838cb0db370d837d5b0
-  data.tar.gz: 55269457dce1d236e620b1f6a1f71b017ee724363363af2fb24e63f7bd583ad7
+  metadata.gz: f619f51cc389c49dbd52a00f22a6fc3766822a9d689eaea44d5fcfbb94e5bfe2
+  data.tar.gz: 79e3718a784f510d72156f071551af20bba3c2d9177ed4b9a2e9791917337947
 SHA512:
-  metadata.gz: 630727692a8c0ec33456f0a3438a64b1aac25e14f4385803744b9ae992f97ca32ac3a914aead6b3901a102f9a4d7ad53c758cbd9e5a53baa314f9634a07799c5
-  data.tar.gz: e50b7fef90457e4a1941d8f96879775226a7b999cb90b579db36f82a98fb3dbd96e4cc367029b431c1d021f44b44c9521bd94ef32060a31ccb89682ed1f6be18
+  metadata.gz: 03ce5eeb1e672cc09815d80a505a0cf2974bbd378c0f3c38245168100a82b59783a45aacd2afb149b0e9814df8ecbd7114fb1eda4738dc8bfa772c5cfa104809
+  data.tar.gz: f26bf3d36e183c2aa7585a36349599092f84347fb45f6325b21c196e37b8893a6102afc7a169efa50a880c408c406ca09a0b80af7e5bd87dbac0b5538960e509

data/.reek.yml

@@ -36,3 +36,6 @@ detectors:
     - Gemkeeper::CLI::Commands::Server::Start
     - Gemkeeper::CLI::Commands::Server::Stop
     - Gemkeeper::CLI::Commands::Server::Status
+    - Gemkeeper::CLI::Commands::Manifest
+    - Gemkeeper::CLI::Commands::Manifest::Generate
+    - Gemkeeper::CLI::Commands::Manifest::Validate

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-05-27
+
+### Added
+
+- `gemkeeper manifest generate LOCKFILE_PATH` builds or updates the gem manifest from a Gemfile.lock.
+  Merges with any existing manifest by default; `--force` overwrites it entirely.
+  Accepts `--manifest` to specify a non-default path.
+- `gemkeeper manifest validate [PATH]` checks a manifest file for structural errors: missing fields, invalid repo URLs, duplicate names, and malformed `source_url`.
+  `--resolve` additionally probes each repo with `git ls-remote` (5s timeout per entry) to verify reachability.
+- During interactive `gemkeeper setup`, gems with inaccessible source repos can now be skipped.
+  Enter nothing when no URL can be inferred, or type `skip` at any prompt.
+
 ## [0.4.0] - 2026-05-27
 
 ### Added
@@ -55,7 +67,8 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/danhorst/gemkeeper/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/danhorst/gemkeeper/compare/0.4.0...0.5.0
 [0.4.0]: https://github.com/danhorst/gemkeeper/compare/0.3.0...0.4.0
 [0.3.0]: https://github.com/danhorst/gemkeeper/compare/0.2.1...0.3.0
 [0.2.1]: https://github.com/danhorst/gemkeeper/compare/0.2.0...0.2.1

data/lib/gemkeeper/bundler_mirror_configurator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  # Configures Bundler mirror settings so private gem registries proxy through local Geminabox.
+  class BundlerMirrorConfigurator
+    def initialize(candidates, port:, global:)
+      @remotes = candidates.filter_map { |c| c[:remote] if c[:source_type] == :private_gem }.uniq
+      @local_url = "http://localhost:#{port}"
+      @scope = global ? "--global" : "--local"
+    end
+
+    def configure(output: $stdout)
+      return if @remotes.empty?
+
+      output.puts ""
+      @remotes.each { |remote| configure_mirror(remote, output) }
+    end
+
+    private
+
+    def configure_mirror(remote, output)
+      if system("bundle", "config", "set", @scope, "mirror.#{remote}", @local_url, out: File::NULL)
+        output.puts "Configured: bundle config set #{@scope} mirror.#{remote} #{@local_url}"
+      else
+        warn "Warning: failed to configure bundler mirror for #{remote}"
+        warn "  Run manually: bundle config set #{@scope} mirror.#{remote} #{@local_url}"
+      end
+    end
+  end
+end

data/lib/gemkeeper/cli/commands/manifest/generate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      module Manifest
+        class Generate < Dry::CLI::Command
+          desc "Build or update the gem manifest from a Gemfile.lock"
+
+          argument :lockfile_path, type: :string, required: true,
+                                   desc: "Path to the project's Gemfile.lock"
+          option :manifest, type: :string,
+                            desc: "Path to write manifest (default: ~/.config/gemkeeper/manifest.yml)"
+          option :force, type: :boolean, default: false,
+                         desc: "Overwrite existing manifest entirely"
+
+          def call(lockfile_path:, **options)
+            path = manifest_path(options)
+            manifest = ManifestReader.load(path)
+            manifest.clear! if options[:force]
+            result = ManifestBuilder.build(lockfile_path:, manifest:)
+
+            if result.empty?
+              puts "No internal gem sources found in #{lockfile_path}"
+              return
+            end
+
+            if result.any_changes?
+              manifest.save(path)
+              puts "Wrote #{path}"
+            end
+
+            print_summary(result, result.any_changes? ? nil : "Manifest up to date, no changes")
+          rescue UnresolvableGemError, ManifestConflictError => error
+            warn "Error: #{error.message}"
+            exit 1
+          end
+
+          private
+
+          def manifest_path(options)
+            options[:manifest] || ManifestReader::DEFAULT_PATH
+          end
+
+          def print_summary(result, no_change_message)
+            if no_change_message
+              puts no_change_message
+              return
+            end
+
+            parts = []
+            parts << "#{result.added_count} added" if result.added_count.positive?
+            parts << "#{result.skipped_count} skipped" if result.skipped_count.positive?
+            parts << "#{result.already_mapped_count} already mapped" if result.already_mapped_count.positive?
+            puts parts.join(", ") if parts.any?
+          end
+        end
+      end
+    end
+
+    register "manifest generate", Commands::Manifest::Generate
+  end
+end

data/lib/gemkeeper/cli/commands/manifest/validate.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  module CLI
+    module Commands
+      module Manifest
+        class Validate < Dry::CLI::Command
+          desc "Validate a gem manifest file"
+
+          argument :path, type: :string, required: false,
+                          desc: "Path to manifest (default: ~/.config/gemkeeper/manifest.yml)"
+          option :resolve, type: :boolean, default: false,
+                           desc: "Also verify each repo is reachable via git ls-remote"
+
+          def call(path: nil, **options)
+            manifest_path = path || ManifestReader::DEFAULT_PATH
+            validator = ManifestValidator.new(manifest_path)
+
+            puts "Checking #{manifest_path}..." if options[:resolve]
+            errors = validator.validate(resolve: options[:resolve], output: $stdout)
+
+            if errors.empty?
+              entry_count = entry_count(manifest_path)
+              puts "#{manifest_path}: valid (#{entry_count} #{entry_count == 1 ? "entry" : "entries"})"
+            else
+              warn "#{manifest_path}: #{errors.size} #{"error".then { |w| errors.size == 1 ? w : "#{w}s" }}"
+              errors.each { |e| warn "  #{e}" }
+              exit 1
+            end
+          end
+
+          private
+
+          def entry_count(path)
+            ManifestReader.load(path).gems.size
+          end
+        end
+      end
+    end
+
+    register "manifest validate", Commands::Manifest::Validate
+  end
+end

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

@@ -40,12 +40,8 @@ module Gemkeeper
 
         def setup_from_lockfile(lockfile_path, output_path, options)
           manifest = load_manifest(options)
-          candidates = LockfileParser.internal_sources(lockfile_path)
-
-          unless candidates.empty?
-            GemRepoResolver.new(candidates:, manifest:).resolve!
-            manifest.save(manifest_path(options))
-          end
+          result = ManifestBuilder.build(lockfile_path:, manifest:)
+          manifest.save(manifest_path(options)) if result.any_changes?
 
           lockfile_versions = LockfileParser.parse(lockfile_path)
           global_output_path = options[:global] ? output_path : nil
@@ -54,26 +50,10 @@ module Gemkeeper
 
           File.write(output_path, config.to_yaml)
           puts "Wrote #{output_path}"
-          configure_bundler(candidates, config, options) unless options[:skip_bundler_config]
-        end
-
-        def configure_bundler(candidates, config, options)
-          remotes = candidates.filter_map { |c| c[:remote] if c[:source_type] == :private_gem }.uniq
-          return if remotes.empty?
+          return if options[:skip_bundler_config]
 
           port = config.fetch("port", Configuration::DEFAULT_PORT)
-          local_url = "http://localhost:#{port}"
-          scope = options[:global] ? "--global" : "--local"
-
-          puts ""
-          remotes.each do |remote|
-            if system("bundle", "config", "set", scope, "mirror.#{remote}", local_url, out: File::NULL)
-              puts "Configured: bundle config set #{scope} mirror.#{remote} #{local_url}"
-            else
-              warn "Warning: failed to configure bundler mirror for #{remote}"
-              warn "  Run manually: bundle config set #{scope} mirror.#{remote} #{local_url}"
-            end
-          end
+          BundlerMirrorConfigurator.new(result.candidates, port:, global: options[:global]).configure
         end
 
         def setup_from_config(source_path, output_path, options)
@@ -105,9 +85,7 @@ module Gemkeeper
           existing_gems = existing["gems"] || []
           source_gems = source["gems"] || []
           existing_repos = existing_gems.to_set { |g| g["repo"] }
-          merged = existing_gems.dup
-          source_gems.each { |g| merged << g unless existing_repos.include?(g["repo"]) }
-          merged
+          existing_gems + source_gems.reject { |g| existing_repos.include?(g["repo"]) }
         end
 
         def load_manifest(options)

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

@@ -12,8 +12,8 @@ module Gemkeeper
         def call(gem_name: nil, **options)
           config = Configuration.load(options[:config])
           gems_to_sync = select_gems(config, gem_name)
-          uploader = GemUploader.new(config.geminabox_url)
-          counts, failures = run_sync(gems_to_sync, config, uploader)
+          syncer = GemSyncer.new(config, GemUploader.new(config.geminabox_url))
+          counts, failures = run_sync(gems_to_sync, syncer)
           report_results(counts, failures, gems_to_sync.size)
         end
 
@@ -36,12 +36,11 @@ module Gemkeeper
           gems
         end
 
-        def run_sync(gems_to_sync, config, uploader)
+        def run_sync(gems_to_sync, syncer)
           counts = { synced: 0, skipped: 0 }
           failures = []
           gems_to_sync.each do |gem_def|
-            result = sync_gem(gem_def, config, uploader)
-            counts[result] += 1
+            counts[syncer.sync(gem_def)] += 1
           rescue Error => error
             failures << { name: gem_def.name, message: error.message }
           end
@@ -64,100 +63,6 @@ module Gemkeeper
           failures.each { |f| warn "  #{f[:name]}: #{f[:message]}" }
           exit 1
         end
-
-        def sync_gem(gem_def, config, uploader)
-          name = gem_def.name
-          repo_url = gem_def.repo
-          gems_path = config.gems_path
-          version = resolve_version(gem_def)
-
-          latest = gem_def.latest?
-          return :skipped if !latest && cached?(name, version, gems_path)
-
-          puts "Syncing #{name} @ #{version}..."
-
-          local_path = File.join(config.repos_path, name)
-          repo = GitRepository.new(repo_url, local_path)
-
-          Output.step("Fetching from #{repo_url}...")
-          fetch_repo(repo, repo_url)
-
-          checkout_gem_version(repo, version)
-
-          if latest
-            version = repo.current_version or
-              raise BuildError, "Could not read version from gemspec in #{repo_url}"
-            return :skipped if cached?(name, version, gems_path)
-          end
-
-          Output.step("Building gem...")
-          gem_path = GemBuilder.new(local_path, gems_path).build
-
-          Output.step("Uploading to Geminabox...")
-          result = uploader.upload(gem_path)
-          Output.step(result[:message])
-          Output.success("  Done!")
-          :synced
-        end
-
-        def resolve_version(gem_def)
-          return gem_def.version unless gem_def.from_lockfile?
-
-          name = gem_def.name
-          lockfile_path = LockfileParser.find
-          unless lockfile_path
-            raise GitError,
-                  "version: from_lockfile for #{name} — no Gemfile.lock found in " \
-                  "#{Dir.pwd} or any parent directory"
-          end
-
-          versions = LockfileParser.parse(lockfile_path)
-          version = versions[name]
-          raise GitError, "#{name} not found in #{lockfile_path}" unless version
-
-          version
-        end
-
-        def cached?(name, version, gems_path)
-          bare_version = version.delete_prefix("v")
-          gem_file = File.join(gems_path, "gems", "#{name}-#{bare_version}.gem")
-          if File.exist?(gem_file)
-            Output.skip("Skipping #{name} @ #{bare_version} (already cached)")
-            true
-          else
-            false
-          end
-        end
-
-        def fetch_repo(repo, repo_url)
-          repo.clone_or_pull
-        rescue GitError => git_error
-          raise auth_error?(git_error) ? auth_failure_error(repo_url, git_error) : git_error
-        end
-
-        def checkout_gem_version(repo, version)
-          Output.step("Checking out #{version}...")
-          repo.checkout_version(version)
-        end
-
-        def auth_error?(error)
-          auth_patterns = [
-            /authentication failed/i,
-            /could not read from remote repository/i,
-            /permission denied \(publickey\)/i,
-            /repository not found/i,
-            /fatal: credential/i
-          ]
-          auth_patterns.any? { |pat| error.message.match?(pat) }
-        end
-
-        def auth_failure_error(repo_url, original_error)
-          GitError.new(
-            "Git authentication failed for #{repo_url}.\n" \
-            "#{original_error.message}\n" \
-            "Configure GitHub credentials: https://docs.github.com/en/authentication"
-          )
-        end
       end
     end
 

data/lib/gemkeeper/cli.rb

@@ -19,3 +19,5 @@ require_relative "cli/commands/list"
 require_relative "cli/commands/server/start"
 require_relative "cli/commands/server/stop"
 require_relative "cli/commands/server/status"
+require_relative "cli/commands/manifest/generate"
+require_relative "cli/commands/manifest/validate"

data/lib/gemkeeper/gem_repo_resolver.rb

@@ -5,6 +5,8 @@ module Gemkeeper
   # GIT-sourced gems are added automatically; private gem registry entries
   # are inferred where possible (GitHub Packages) or prompted interactively.
   class GemRepoResolver
+    SKIP_INPUT = "skip"
+
     def initialize(candidates:, manifest:, input: $stdin, output: $stdout)
       @candidates = candidates
       @manifest = manifest
@@ -14,37 +16,36 @@ module Gemkeeper
 
     def resolve!
       unresolvable = []
-
-      @candidates.each do |candidate|
-        name = candidate[:name]
-        next if @manifest.repo_for(name)
-
-        if candidate[:source_type] == :git
-          @manifest.add_mapping(name:, repo: candidate[:repo])
-        else
-          repo = resolve_private_gem(candidate)
-          if repo
-            @manifest.add_mapping(name:, repo:)
-          else
-            unresolvable << candidate
-          end
-        end
-      end
-
+      @candidates.each { |candidate| resolve_candidate(candidate, unresolvable) }
       raise_unresolvable(unresolvable) if unresolvable.any?
       @manifest
     end
 
     private
 
-    def resolve_private_gem(candidate)
-      inferred = infer_repo(candidate)
+    def resolve_candidate(candidate, unresolvable)
+      return if @manifest.repo_for(candidate[:name])
+      return @manifest.add_mapping(name: candidate[:name], repo: candidate[:repo]) if candidate[:source_type] == :git
+
+      interactive? ? resolve_interactively(candidate) : resolve_non_interactively(candidate, unresolvable)
+    end
 
-      if interactive?
-        prompt(candidate, inferred)
-      elsif inferred
-        warn "Note: auto-inferred repo for #{candidate[:name]}: #{inferred}"
-        inferred
+    def resolve_interactively(candidate)
+      repo = prompt(candidate, infer_repo(candidate))
+      if repo
+        @manifest.add_mapping(name: candidate[:name], repo:)
+      else
+        @output.puts "  Skipping #{candidate[:name]}"
+      end
+    end
+
+    def resolve_non_interactively(candidate, unresolvable)
+      repo = infer_repo(candidate)
+      if repo
+        warn "Note: auto-inferred repo for #{candidate[:name]}: #{repo}"
+        @manifest.add_mapping(name: candidate[:name], repo:)
+      else
+        unresolvable << candidate
       end
     end
 
@@ -57,12 +58,18 @@ module Gemkeeper
 
     def prompt(candidate, inferred)
       @output.print "\n  #{candidate[:name]} (from #{candidate[:remote]})"
-      @output.print "\n  Repo URL"
-      @output.print " [#{inferred}]" if inferred
-      @output.print ": "
-      input = @input.gets&.strip
-      input = inferred if input.nil? || input.empty?
-      input
+      @output.print "\n  Repo URL#{prompt_hint(inferred)}: "
+      parse_prompt_input(@input.gets&.strip, inferred)
+    end
+
+    def prompt_hint(inferred)
+      inferred ? " [#{inferred}] (or \"#{SKIP_INPUT}\" to skip)" : " (blank to skip)"
+    end
+
+    def parse_prompt_input(input, inferred)
+      return nil if input.nil? || input == SKIP_INPUT || (input.empty? && inferred.nil?)
+
+      input.empty? ? inferred : input
     end
 
     def interactive?

data/lib/gemkeeper/gem_syncer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  # Syncs a single gem: resolves version, checks cache, clones/pulls, builds, uploads.
+  class GemSyncer
+    AUTH_ERROR_PATTERNS = [
+      /authentication failed/i,
+      /could not read from remote repository/i,
+      /permission denied \(publickey\)/i,
+      /repository not found/i,
+      /fatal: credential/i
+    ].freeze
+
+    def initialize(config, uploader)
+      @config = config
+      @uploader = uploader
+    end
+
+    def sync(gem_def)
+      version = resolve_version(gem_def)
+      name = gem_def.name
+      gems_path = @config.gems_path
+
+      return :skipped if !gem_def.latest? && cached?(name, version, gems_path)
+
+      puts "Syncing #{name} @ #{version}..."
+      local_path = File.join(@config.repos_path, name)
+      repo = fetch_repo(gem_def.repo, local_path)
+
+      Output.step("Checking out #{version}...")
+      repo.checkout_version(version)
+
+      if gem_def.latest?
+        version = latest_version!(repo, name, gems_path, gem_def.repo)
+        return :skipped unless version
+      end
+
+      build_and_upload(local_path, gems_path)
+      :synced
+    end
+
+    private
+
+    def resolve_version(gem_def)
+      return gem_def.version unless gem_def.from_lockfile?
+
+      lockfile_path = LockfileParser.find
+      unless lockfile_path
+        raise GitError,
+              "version: from_lockfile for #{gem_def.name} — no Gemfile.lock found in " \
+              "#{Dir.pwd} or any parent directory"
+      end
+
+      versions = LockfileParser.parse(lockfile_path)
+      versions[gem_def.name] or raise GitError, "#{gem_def.name} not found in #{lockfile_path}"
+    end
+
+    def cached?(name, version, gems_path)
+      bare = version.delete_prefix("v")
+      gem_file = File.join(gems_path, "gems", "#{name}-#{bare}.gem")
+      return false unless File.exist?(gem_file)
+
+      Output.skip("Skipping #{name} @ #{bare} (already cached)")
+      true
+    end
+
+    def fetch_repo(repo_url, local_path)
+      repo = GitRepository.new(repo_url, local_path)
+      Output.step("Fetching from #{repo_url}...")
+      repo.clone_or_pull
+      repo
+    rescue GitError => git_error
+      raise auth_error?(git_error) ? auth_failure_error(repo_url, git_error) : git_error
+    end
+
+    def latest_version!(repo, name, gems_path, repo_url)
+      version = repo.current_version or
+        raise BuildError, "Could not read version from gemspec in #{repo_url}"
+      cached?(name, version, gems_path) ? nil : version
+    end
+
+    def build_and_upload(local_path, gems_path)
+      Output.step("Building gem...")
+      gem_path = GemBuilder.new(local_path, gems_path).build
+      Output.step("Uploading to Geminabox...")
+      result = @uploader.upload(gem_path)
+      Output.step(result[:message])
+      Output.success("  Done!")
+    end
+
+    def auth_error?(error)
+      AUTH_ERROR_PATTERNS.any? { |pat| error.message.match?(pat) }
+    end
+
+    def auth_failure_error(repo_url, original_error)
+      GitError.new(
+        "Git authentication failed for #{repo_url}.\n" \
+        "#{original_error.message}\n" \
+        "Configure GitHub credentials: https://docs.github.com/en/authentication"
+      )
+    end
+  end
+end

data/lib/gemkeeper/manifest_builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gemkeeper
+  # Builds or updates a manifest from a Gemfile.lock, tracking what changed.
+  class ManifestBuilder
+    Result = Struct.new(:manifest, :candidates, :added_count, :skipped_count, :already_mapped_count,
+                        keyword_init: true) do
+      def any_changes?
+        added_count.positive?
+      end
+
+      def empty?
+        candidates.empty?
+      end
+    end
+
+    def self.build(lockfile_path:, manifest:, input: $stdin, output: $stdout)
+      new(lockfile_path:, manifest:).build!(input:, output:)
+    end
+
+    def initialize(lockfile_path:, manifest:)
+      @lockfile_path = lockfile_path
+      @manifest = manifest
+    end
+
+    def build!(input: $stdin, output: $stdout)
+      candidates = LockfileParser.internal_sources(@lockfile_path)
+      already_mapped_count = candidates.count { |c| @manifest.repo_for(c[:name]) }
+      before_size = @manifest.gems.size
+
+      GemRepoResolver.new(candidates:, manifest: @manifest, input:, output:).resolve! unless candidates.empty?
+
+      added_count = @manifest.gems.size - before_size
+      skipped_count = candidates.size - already_mapped_count - added_count
+
+      Result.new(manifest: @manifest, candidates:, added_count:, skipped_count:, already_mapped_count:)
+    end
+  end
+end

data/lib/gemkeeper/manifest_reader.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "fileutils"
-
 module Gemkeeper
   # Decouples manifest format from sync/setup commands that need the eligible gem list.
   class ManifestReader
@@ -18,7 +15,13 @@ module Gemkeeper
       @path = path
       @gems = []
       @source_url = nil
-      parse_manifest if File.exist?(@path)
+      load_from_disk if File.exist?(@path)
+    end
+
+    def clear!
+      @gems = []
+      @source_url = nil
+      self
     end
 
     def gem_names
@@ -46,21 +49,15 @@ module Gemkeeper
     end
 
     def save(path = @path)
-      FileUtils.mkdir_p(File.dirname(path))
-      data = {}
-      data["source_url"] = @source_url if @source_url
-      data["gems"] = @gems.map { |g| { "name" => g[:name], "repo" => g[:repo] } }
-      File.write(path, data.to_yaml)
+      ManifestSerializer.save(path, gems: @gems, source_url: @source_url)
     end
 
     private
 
-    def parse_manifest
-      data = YAML.safe_load_file(@path, permitted_classes: [], symbolize_names: true) || {}
+    def load_from_disk
+      data = ManifestSerializer.load(@path)
       @source_url = data[:source_url]&.to_s
-      @gems = (data[:gems] || []).map do |entry|
-        { name: entry[:name].to_s, repo: entry[:repo].to_s }
-      end
+      @gems = (data[:gems] || []).map { |entry| { name: entry[:name].to_s, repo: entry[:repo].to_s } }
     end
 
     def conflict_message(name, existing_repo, new_repo)

data/lib/gemkeeper/manifest_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Gemkeeper
+  # Handles YAML read/write for the gem manifest file.
+  module ManifestSerializer
+    def self.load(path)
+      return {} unless File.exist?(path)
+
+      YAML.safe_load_file(path, permitted_classes: [], symbolize_names: true) || {}
+    end
+
+    def self.save(path, gems:, source_url:)
+      FileUtils.mkdir_p(File.dirname(path))
+      data = {}
+      data["source_url"] = source_url if source_url
+      data["gems"] = gems.map { |g| { "name" => g[:name], "repo" => g[:repo] } }
+      File.write(path, data.to_yaml)
+    end
+  end
+end

data/lib/gemkeeper/manifest_validator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "set"
+require "timeout"
+require "yaml"
+
+module Gemkeeper
+  # Validates a manifest file structurally and, optionally, by probing git remotes.
+  class ManifestValidator
+    VALID_GIT_URL = %r{\A(git@|https?://|ssh://)}
+    VALID_HTTP_URL = %r{\Ahttps?://}
+    RESOLVE_TIMEOUT = 5
+
+    def initialize(path)
+      @path = path
+    end
+
+    def validate(resolve: false, output: $stdout)
+      errors = static_errors
+      return errors if errors.any?
+
+      errors + (resolve ? resolve_errors(output) : [])
+    end
+
+    private
+
+    def static_errors
+      return ["File not found: #{@path}"] unless File.exist?(@path)
+
+      data = load_yaml
+      return [data] if data.is_a?(String)
+
+      structure_errors(data) + entry_errors(data)
+    end
+
+    def load_yaml
+      @data = YAML.safe_load_file(@path, permitted_classes: [], symbolize_names: false) || {}
+    rescue Psych::SyntaxError => e
+      "Invalid YAML: #{e.message}"
+    end
+
+    def structure_errors(data)
+      errors = []
+      source_url = data["source_url"].to_s
+      errors << "source_url is not a valid HTTP(S) URL" if data.key?("source_url") && !source_url.match?(VALID_HTTP_URL)
+      errors << "gems must be a list" if data.key?("gems") && !data["gems"].is_a?(Array)
+      errors
+    end
+
+    def entry_errors(data)
+      return [] unless data["gems"].is_a?(Array)
+
+      seen = Set.new
+      data["gems"].each_with_index.flat_map { |entry, i| single_entry_errors(entry, i, seen) }
+    end
+
+    def single_entry_errors(entry, index, seen)
+      name = entry["name"].to_s.strip
+      repo = entry["repo"].to_s.strip
+      label = name.empty? ? "gems[#{index}]" : "gems[#{index}] (#{name})"
+
+      field_errors(label, name, repo) + duplicate_errors(label, name, seen)
+    end
+
+    def field_errors(label, name, repo)
+      errors = []
+      errors << "#{label}: missing name" if name.empty?
+      errors << "#{label}: missing repo" if repo.empty?
+      errors << "#{label}: repo does not look like a git URL" if !repo.empty? && !repo.match?(VALID_GIT_URL)
+      errors
+    end
+
+    def duplicate_errors(label, name, seen)
+      return [] if name.empty?
+
+      if seen.include?(name)
+        ["#{label}: duplicate name"]
+      else
+        seen << name
+        []
+      end
+    end
+
+    def resolve_errors(output)
+      (@data["gems"] || []).flat_map { |entry| probe_repo(entry["name"], entry["repo"], output) }
+    end
+
+    def probe_repo(name, repo, output)
+      reachable = Timeout.timeout(RESOLVE_TIMEOUT) do
+        system("git", "ls-remote", repo, "--quiet", out: File::NULL, err: File::NULL)
+      end
+      output.puts "  #{name}: #{reachable ? "reachable" : "FAILED"}"
+      reachable ? [] : ["#{name} (#{repo}): unreachable"]
+    rescue Timeout::Error
+      output.puts "  #{name}: timed out"
+      ["#{name} (#{repo}): timed out after #{RESOLVE_TIMEOUT}s"]
+    end
+  end
+end

data/lib/gemkeeper/rackup_process.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "uri"
+
+module Gemkeeper
+  # Builds config.ru, spawns the rackup/puma process, and waits for HTTP readiness.
+  class RackupProcess
+    def initialize(config)
+      @config = config
+    end
+
+    def start
+      generate_config_ru
+      Dir.chdir(@config.cache_dir) { launch_daemon }
+      wait_for_server
+    end
+
+    def start_foreground
+      generate_config_ru
+      Dir.chdir(@config.cache_dir) { system(*build_rackup_cmd) }
+    end
+
+    private
+
+    def generate_config_ru
+      FileUtils.mkdir_p(@config.cache_dir)
+      FileUtils.mkdir_p(@config.gems_path)
+      File.write(@config.config_ru_path, config_ru_content)
+    end
+
+    def config_ru_content
+      gems_path = @config.gems_path
+      <<~RUBY
+        # frozen_string_literal: true
+        # Auto-generated by Gemkeeper
+
+        require "rubygems/indexer"
+        require "geminabox"
+
+        Geminabox.data = #{gems_path.inspect}
+        Geminabox.rubygems_proxy = true
+
+        run Geminabox::Server
+      RUBY
+    end
+
+    def build_rackup_cmd(*extra)
+      ["rackup", @config.config_ru_path, "--host", "127.0.0.1",
+       "-p", @config.port.to_s, "-s", "puma", *extra]
+    end
+
+    def launch_daemon
+      _stdout, stderr, status = Open3.capture3(*build_rackup_cmd("-D", "-P", @config.pid_file))
+      raise ServerError, "Failed to start server:\n#{stderr}" unless status.success? || File.exist?(@config.pid_file)
+    end
+
+    def wait_for_server
+      ServerReadinessProbe.new(@config.geminabox_url).wait
+    end
+  end
+end

data/lib/gemkeeper/server_manager.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
 require "fileutils"
 
 module Gemkeeper
@@ -14,14 +13,12 @@ module Gemkeeper
 
     def start
       ensure_not_running!
-      generate_config_ru
-      start_server
+      RackupProcess.new(config).start
     end
 
     def start_foreground
       ensure_not_running!
-      generate_config_ru
-      start_server_foreground
+      RackupProcess.new(config).start_foreground
     end
 
     def stop
@@ -60,58 +57,6 @@ module Gemkeeper
       raise ServerAlreadyRunningError, "Server is already running (PID: #{read_pid})" if running?
     end
 
-    def generate_config_ru
-      gems_path = config.gems_path
-      FileUtils.mkdir_p(config.cache_dir)
-      FileUtils.mkdir_p(gems_path)
-
-      content = <<~RUBY
-        # frozen_string_literal: true
-        # Auto-generated by Gemkeeper
-
-        require "rubygems/indexer"
-        require "geminabox"
-
-        Geminabox.data = #{gems_path.inspect}
-        Geminabox.rubygems_proxy = true
-
-        run Geminabox::Server
-      RUBY
-
-      File.write(config.config_ru_path, content)
-    end
-
-    def build_rackup_cmd(*extra)
-      ["rackup", config.config_ru_path, "--host", "127.0.0.1", "-p", config.port.to_s, "-s", "puma", *extra]
-    end
-
-    def build_start_cmd
-      build_rackup_cmd("-D", "-P", config.pid_file)
-    end
-
-    def build_foreground_cmd
-      build_rackup_cmd
-    end
-
-    def start_server
-      cmd = build_start_cmd
-
-      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
-      Dir.chdir(config.cache_dir) do
-        system(*build_foreground_cmd)
-      end
-    end
-
     def wait_for_process_exit(pid)
       10.times do
         return unless process_alive?(pid)
@@ -121,26 +66,6 @@ module Gemkeeper
       Process.kill("KILL", pid) if process_alive?(pid)
     end
 
-    def wait_for_server(timeout: 10)
-      require "net/http"
-
-      uri = URI(config.geminabox_url)
-      (timeout / 0.5).ceil.times do
-        return true if server_responding?(uri)
-
-        sleep 0.5
-      end
-
-      raise ServerError, "Server failed to start within #{timeout} seconds"
-    end
-
-    def server_responding?(uri)
-      response = Net::HTTP.get_response(uri)
-      response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
-    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, SocketError
-      false
-    end
-
     def read_pid
       pid_file = config.pid_file
       return nil unless File.exist?(pid_file)

data/lib/gemkeeper/server_readiness_probe.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Gemkeeper
+  # Polls the server's HTTP endpoint until it responds or a timeout is reached.
+  class ServerReadinessProbe
+    def initialize(url)
+      @uri = URI(url)
+    end
+
+    def wait(timeout: 10)
+      (timeout / 0.5).ceil.times do
+        return true if responding?
+
+        sleep 0.5
+      end
+      raise ServerError, "Server failed to start within #{timeout} seconds"
+    end
+
+    private
+
+    def responding?
+      response = Net::HTTP.get_response(@uri)
+      response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, SocketError
+      false
+    end
+  end
+end

data/lib/gemkeeper/version.rb

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

data/lib/gemkeeper.rb

@@ -6,7 +6,14 @@ require_relative "gemkeeper/output"
 require_relative "gemkeeper/configuration"
 require_relative "gemkeeper/lockfile_parser"
 require_relative "gemkeeper/manifest_reader"
+require_relative "gemkeeper/manifest_serializer"
 require_relative "gemkeeper/gem_repo_resolver"
+require_relative "gemkeeper/manifest_builder"
+require_relative "gemkeeper/manifest_validator"
+require_relative "gemkeeper/bundler_mirror_configurator"
+require_relative "gemkeeper/gem_syncer"
+require_relative "gemkeeper/rackup_process"
+require_relative "gemkeeper/server_readiness_probe"
 require_relative "gemkeeper/config_generator"
 require_relative "gemkeeper/git_repository"
 require_relative "gemkeeper/gem_builder"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemkeeper
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Dan Brubaker Horst
@@ -95,8 +95,11 @@ files:
 - README.md
 - exe/gemkeeper
 - lib/gemkeeper.rb
+- lib/gemkeeper/bundler_mirror_configurator.rb
 - lib/gemkeeper/cli.rb
 - lib/gemkeeper/cli/commands/list.rb
+- lib/gemkeeper/cli/commands/manifest/generate.rb
+- lib/gemkeeper/cli/commands/manifest/validate.rb
 - lib/gemkeeper/cli/commands/server/start.rb
 - lib/gemkeeper/cli/commands/server/status.rb
 - lib/gemkeeper/cli/commands/server/stop.rb
@@ -108,12 +111,18 @@ files:
 - lib/gemkeeper/errors.rb
 - lib/gemkeeper/gem_builder.rb
 - lib/gemkeeper/gem_repo_resolver.rb
+- lib/gemkeeper/gem_syncer.rb
 - lib/gemkeeper/gem_uploader.rb
 - lib/gemkeeper/git_repository.rb
 - lib/gemkeeper/lockfile_parser.rb
+- lib/gemkeeper/manifest_builder.rb
 - lib/gemkeeper/manifest_reader.rb
+- lib/gemkeeper/manifest_serializer.rb
+- lib/gemkeeper/manifest_validator.rb
 - lib/gemkeeper/output.rb
+- lib/gemkeeper/rackup_process.rb
 - lib/gemkeeper/server_manager.rb
+- lib/gemkeeper/server_readiness_probe.rb
 - lib/gemkeeper/version.rb
 - mise.toml
 - sig/gemkeeper.rbs