Implement stateless command execution for list, show, and diff commands

Author: andrew

CHANGELOG.md

@@ -1,6 +1,8 @@
 ## [Unreleased]
 
+- `--stateless` flag for `list`, `show`, and `diff` commands (auto-enabled when no database exists)
 - Fix `-f` flag conflict in `diff` command (was defined for both `--from` and `--format`)
+- Disable GPG signing in test suite for faster tests
 
 ## [0.6.2] - 2026-01-06
 

README.md

@@ -98,6 +98,7 @@ git pkgs list
 git pkgs list --commit=abc123
 git pkgs list --ecosystem=rubygems
 git pkgs list --manifest=Gemfile
+git pkgs list --stateless           # parse manifests directly, no database needed
 ```
 
 Example output:
@@ -247,6 +248,7 @@ Shows dependencies sorted by how long since they were last changed in your repo.
 ```bash
 git pkgs diff --from=abc123 --to=def456
 git pkgs diff --from=HEAD~10
+git pkgs diff main..feature --stateless  # no database needed
 ```
 
 This shows added, removed, and modified packages with version info.
@@ -257,6 +259,7 @@ This shows added, removed, and modified packages with version info.
 git pkgs show              # show dependency changes in HEAD
 git pkgs show abc123       # specific commit
 git pkgs show HEAD~5       # relative ref
+git pkgs show --stateless  # no database needed
 ```
 
 Like `git show` but for dependencies. Shows what was added, modified, or removed in a single commit.
@@ -327,7 +330,7 @@ Useful for understanding the [database structure](docs/schema.md) or generating
 
 ### CI usage
 
-You can run git-pkgs in CI to show dependency changes in pull requests:
+You can run git-pkgs in CI to show dependency changes in pull requests. Use `--stateless` to skip database initialization for faster runs:
 
 ```yaml
 # .github/workflows/deps.yml
@@ -346,8 +349,7 @@ jobs:
         with:
           ruby-version: '3.3'
       - run: gem install git-pkgs
-      - run: git pkgs init
-      - run: git pkgs diff --from=origin/${{ github.base_ref }} --to=HEAD
+      - run: git pkgs diff --from=origin/${{ github.base_ref }} --to=HEAD --stateless
 ```
 
 ### Diff driver

lib/git/pkgs/analyzer.rb

@@ -288,6 +288,80 @@ def parse_manifest_by_oid(blob_oid, manifest_path)
         @blob_cache[cache_key] = { result: result, hits: 0 }
         result
       end
+
+      # Parse all manifest files at a given commit (stateless)
+      def dependencies_at_commit(rugged_commit)
+        deps = []
+        manifest_paths = find_manifest_paths_in_tree(rugged_commit.tree)
+
+        manifest_paths.each do |path|
+          result = parse_manifest_at_commit(rugged_commit, path)
+          next unless result && result[:dependencies]
+
+          result[:dependencies].each do |dep|
+            deps << {
+              manifest_path: path,
+              name: dep[:name],
+              ecosystem: result[:platform],
+              requirement: dep[:requirement],
+              dependency_type: dep[:type]
+            }
+          end
+        end
+
+        deps
+      end
+
+      # Compute changes between two commits (stateless)
+      def diff_commits(from_commit, to_commit)
+        from_deps = dependencies_at_commit(from_commit).group_by { |d| [d[:manifest_path], d[:name]] }
+        to_deps = dependencies_at_commit(to_commit).group_by { |d| [d[:manifest_path], d[:name]] }
+
+        added = []
+        modified = []
+        removed = []
+
+        # Find added and modified
+        to_deps.each do |key, to_list|
+          to_dep = to_list.first
+          if from_deps[key]
+            from_dep = from_deps[key].first
+            if from_dep[:requirement] != to_dep[:requirement]
+              modified << to_dep.merge(previous_requirement: from_dep[:requirement])
+            end
+          else
+            added << to_dep
+          end
+        end
+
+        # Find removed
+        from_deps.each do |key, from_list|
+          removed << from_list.first unless to_deps[key]
+        end
+
+        { added: added, modified: modified, removed: removed }
+      end
+
+      def find_manifest_paths_in_tree(tree, prefix = "")
+        paths = []
+
+        tree.each do |entry|
+          full_path = prefix.empty? ? entry[:name] : "#{prefix}/#{entry[:name]}"
+
+          if entry[:type] == :tree
+            subtree = repository.lookup(entry[:oid])
+            paths.concat(find_manifest_paths_in_tree(subtree, full_path))
+          elsif entry[:type] == :blob && full_path.match?(QUICK_MANIFEST_REGEX)
+            paths << full_path
+          end
+        end
+
+        identify_manifests_cached(paths)
+      end
+
+      def lookup(oid)
+        repository.lookup(oid)
+      end
     end
   end
 end

lib/git/pkgs/commands/diff.rb

@@ -13,9 +13,7 @@ def initialize(args)
 
         def run
           repo = Repository.new
-          require_database(repo)
-
-          Database.connect(repo.git_dir)
+          use_stateless = @options[:stateless] || !Database.exists?(repo.git_dir)
 
           from_ref, to_ref = parse_range_argument
           from_ref ||= @options[:from]
@@ -30,6 +28,46 @@ def run
           error "Could not resolve '#{from_ref}'. Check that the ref exists." unless from_sha
           error "Could not resolve '#{to_ref}'. Check that the ref exists." unless to_sha
 
+          if use_stateless
+            run_stateless(repo, from_sha, to_sha)
+          else
+            run_with_database(repo, from_sha, to_sha)
+          end
+        end
+
+        def run_stateless(repo, from_sha, to_sha)
+          from_commit = repo.lookup(from_sha)
+          to_commit = repo.lookup(to_sha)
+
+          analyzer = Analyzer.new(repo)
+          diff = analyzer.diff_commits(from_commit, to_commit)
+
+          if @options[:ecosystem]
+            diff[:added] = diff[:added].select { |d| d[:ecosystem] == @options[:ecosystem] }
+            diff[:modified] = diff[:modified].select { |d| d[:ecosystem] == @options[:ecosystem] }
+            diff[:removed] = diff[:removed].select { |d| d[:ecosystem] == @options[:ecosystem] }
+          end
+
+          if diff[:added].empty? && diff[:modified].empty? && diff[:removed].empty?
+            if @options[:format] == "json"
+              require "json"
+              puts JSON.pretty_generate({ from: from_sha[0..7], to: to_sha[0..7], added: [], modified: [], removed: [] })
+            else
+              empty_result "No dependency changes between #{from_sha[0..7]} and #{to_sha[0..7]}"
+            end
+            return
+          end
+
+          if @options[:format] == "json"
+            output_json_stateless(from_sha, to_sha, diff)
+          else
+            paginate { output_text_stateless(from_sha, to_sha, diff) }
+          end
+        end
+
+        def run_with_database(repo, from_sha, to_sha)
+          Database.connect(repo.git_dir)
+
           from_commit = Models::Commit.find_or_create_from_repo(repo, from_sha)
           to_commit = Models::Commit.find_or_create_from_repo(repo, to_sha)
 
@@ -154,6 +192,81 @@ def output_json(from_commit, to_commit, changes)
           puts JSON.pretty_generate(data)
         end
 
+        def output_text_stateless(from_sha, to_sha, diff)
+          puts "Dependency changes from #{from_sha[0..7]} to #{to_sha[0..7]}:"
+          puts
+
+          if diff[:added].any?
+            puts Color.green("Added:")
+            diff[:added].group_by { |d| d[:name] }.each do |name, pkg_changes|
+              latest = pkg_changes.last
+              puts Color.green("  + #{name} #{latest[:requirement]} (#{latest[:manifest_path]})")
+            end
+            puts
+          end
+
+          if diff[:modified].any?
+            puts Color.yellow("Modified:")
+            diff[:modified].group_by { |d| d[:name] }.each do |name, pkg_changes|
+              latest = pkg_changes.last
+              puts Color.yellow("  ~ #{name} #{latest[:previous_requirement]} -> #{latest[:requirement]}")
+            end
+            puts
+          end
+
+          if diff[:removed].any?
+            puts Color.red("Removed:")
+            diff[:removed].group_by { |d| d[:name] }.each do |name, pkg_changes|
+              latest = pkg_changes.last
+              puts Color.red("  - #{name} (was #{latest[:requirement]})")
+            end
+            puts
+          end
+
+          added_count = Color.green("+#{diff[:added].map { |d| d[:name] }.uniq.count}")
+          removed_count = Color.red("-#{diff[:removed].map { |d| d[:name] }.uniq.count}")
+          modified_count = Color.yellow("~#{diff[:modified].map { |d| d[:name] }.uniq.count}")
+          puts "Summary: #{added_count} #{removed_count} #{modified_count}"
+        end
+
+        def output_json_stateless(from_sha, to_sha, diff)
+          require "json"
+
+          format_change = lambda do |change|
+            {
+              name: change[:name],
+              ecosystem: change[:ecosystem],
+              requirement: change[:requirement],
+              manifest: change[:manifest_path]
+            }
+          end
+
+          format_modified = lambda do |change|
+            {
+              name: change[:name],
+              ecosystem: change[:ecosystem],
+              previous_requirement: change[:previous_requirement],
+              requirement: change[:requirement],
+              manifest: change[:manifest_path]
+            }
+          end
+
+          data = {
+            from: from_sha[0..7],
+            to: to_sha[0..7],
+            added: diff[:added].map { |c| format_change.call(c) },
+            modified: diff[:modified].map { |c| format_modified.call(c) },
+            removed: diff[:removed].map { |c| format_change.call(c) },
+            summary: {
+              added: diff[:added].map { |d| d[:name] }.uniq.count,
+              modified: diff[:modified].map { |d| d[:name] }.uniq.count,
+              removed: diff[:removed].map { |d| d[:name] }.uniq.count
+            }
+          }
+
+          puts JSON.pretty_generate(data)
+        end
+
         def parse_range_argument
           return [nil, nil] if @args.empty?
 
@@ -203,6 +316,10 @@ def parse_options
               options[:no_pager] = true
             end
 
+            opts.on("--stateless", "Parse manifests directly without database") do
+              options[:stateless] = true
+            end
+
             opts.on("-h", "--help", "Show this help") do
               puts opts
               exit

lib/git/pkgs/commands/list.rb

@@ -13,16 +13,13 @@ def initialize(args)
 
         def run
           repo = Repository.new
-          require_database(repo)
+          use_stateless = @options[:stateless] || !Database.exists?(repo.git_dir)
 
-          Database.connect(repo.git_dir)
-
-          commit_sha = @options[:commit] || repo.head_sha
-          target_commit = Models::Commit.first(sha: commit_sha)
-
-          error "Commit #{commit_sha[0, 7]} not in database. Run 'git pkgs update' to index new commits." unless target_commit
-
-          deps = compute_dependencies_at_commit(target_commit, repo)
+          if use_stateless
+            deps = run_stateless(repo)
+          else
+            deps = run_with_database(repo)
+          end
 
           # Apply filters
           if @options[:manifest]
@@ -50,6 +47,27 @@ def run
           end
         end
 
+        def run_stateless(repo)
+          commit_sha = @options[:commit] || repo.head_sha
+          rugged_commit = repo.lookup(repo.rev_parse(commit_sha))
+
+          error "Could not resolve '#{commit_sha}'. Check that the ref exists." unless rugged_commit
+
+          analyzer = Analyzer.new(repo)
+          analyzer.dependencies_at_commit(rugged_commit)
+        end
+
+        def run_with_database(repo)
+          Database.connect(repo.git_dir)
+
+          commit_sha = @options[:commit] || repo.head_sha
+          target_commit = Models::Commit.first(sha: commit_sha)
+
+          error "Commit #{commit_sha[0, 7]} not in database. Run 'git pkgs update' to index new commits." unless target_commit
+
+          compute_dependencies_at_commit(target_commit, repo)
+        end
+
         def output_text(deps)
           grouped = deps.group_by { |d| [d[:manifest_path], d[:ecosystem]] }
 
@@ -157,6 +175,10 @@ def parse_options
               options[:no_pager] = true
             end
 
+            opts.on("--stateless", "Parse manifests directly without database") do
+              options[:stateless] = true
+            end
+
             opts.on("-h", "--help", "Show this help") do
               puts opts
               exit