git-pkgs 0.3.0 → 0.5.0

data/README.md

@@ -43,7 +43,7 @@ Options:
 - `--branch=NAME` - analyze a specific branch (default: default branch)
 - `--since=SHA` - start analysis from a specific commit
 - `--force` - rebuild the database from scratch
-- `--hooks` - install git hooks for auto-updating
+- `--no-hooks` - skip installing git hooks (hooks are installed by default)
 
 Example output:
 ```
@@ -52,7 +52,7 @@ Processing commit 5191/5191...
 Done!
 Analyzed 5191 commits
 Found 2531 commits with dependency changes
-Stored 28239 snapshots (every 20 changes)
+Stored 28239 snapshots (every 50 changes)
 Blob cache: 3141 unique blobs, 2349 had cache hits
 ```
 
@@ -86,7 +86,7 @@ Snapshot Coverage
 ----------------------------------------
   Commits with dependency changes: 2531
   Commits with snapshots: 127
-  Coverage: 5.0% (1 snapshot per ~20 changes)
+  Coverage: 2.0% (1 snapshot per ~50 changes)
 ```
 
 ### List dependencies
@@ -258,6 +258,23 @@ git pkgs show HEAD~5       # relative ref
 
 Like `git show` but for dependencies. Shows what was added, modified, or removed in a single commit.
 
+### Find where a package is declared
+
+```bash
+git pkgs where rails           # find in manifest files
+git pkgs where lodash -C 2     # show 2 lines of context
+git pkgs where express --ecosystem=npm
+```
+
+Shows which manifest files declare a package and the exact line:
+
+```
+Gemfile:5:gem "rails", "~> 7.0"
+Gemfile.lock:142:    rails (7.0.8)
+```
+
+Like `grep` but scoped to manifest files that git-pkgs knows about.
+
 ### List commits with dependency changes
 
 ```bash
@@ -270,16 +287,18 @@ Like `git log` but only shows commits that changed dependencies, with the change
 
 ### Keep database updated
 
-After the initial analysis, you can incrementally update the database with new commits:
+After the initial analysis, the database updates automatically via git hooks installed during init. You can also update manually:
 
 ```bash
 git pkgs update
 ```
 
-You can also install git hooks to update automatically after commits and merges:
+To manage hooks separately:
 
 ```bash
-git pkgs hooks --install
+git pkgs hooks              # show hook status
+git pkgs hooks --install    # install hooks
+git pkgs hooks --uninstall  # remove hooks
 ```
 
 ### Upgrading
@@ -328,6 +347,45 @@ jobs:
       - run: git pkgs diff --from=origin/${{ github.base_ref }} --to=HEAD
 ```
 
+### Diff driver
+
+Install a git textconv driver that shows semantic dependency changes instead of raw lockfile diffs:
+
+```bash
+git pkgs diff-driver --install
+```
+
+Now `git diff` on lockfiles shows a sorted dependency list instead of raw lockfile changes:
+
+```diff
+diff --git a/Gemfile.lock b/Gemfile.lock
+--- a/Gemfile.lock
++++ b/Gemfile.lock
+@@ -1,3 +1,3 @@
++kamal 1.0.0
+-puma 5.0.0
++puma 6.0.0
+ rails 7.0.0
+-sidekiq 6.0.0
+```
+
+Use `git diff --no-textconv` to see the raw lockfile diff. To remove: `git pkgs diff-driver --uninstall`
+
+### Shell completions
+
+Enable tab completion for commands:
+
+```bash
+# Bash: add to ~/.bashrc
+eval "$(git pkgs completions bash)"
+
+# Zsh: add to ~/.zshrc
+eval "$(git pkgs completions zsh)"
+
+# Or auto-install to standard completion directories
+git pkgs completions install
+```
+
 ## Configuration
 
 git-pkgs respects [standard git configuration](https://git-scm.com/docs/git-config).
@@ -336,6 +394,21 @@ git-pkgs respects [standard git configuration](https://git-scm.com/docs/git-conf
 
 **Pager** follows git's precedence: `GIT_PAGER` env, `core.pager` config, `PAGER` env, then `less -FRSX`. Use `--no-pager` flag or `git config core.pager cat` to disable.
 
+**Ecosystem filtering** lets you limit which package ecosystems are tracked:
+
+```bash
+git config --add pkgs.ecosystems rubygems
+git config --add pkgs.ecosystems npm
+git pkgs info --ecosystems  # show enabled/disabled ecosystems
+```
+
+**Ignored paths** let you skip directories or files from analysis:
+
+```bash
+git config --add pkgs.ignoredDirs third_party
+git config --add pkgs.ignoredFiles test/fixtures/package.json
+```
+
 **Environment variables:**
 
 - `GIT_DIR` - git directory location (standard git variable)
@@ -343,55 +416,32 @@ git-pkgs respects [standard git configuration](https://git-scm.com/docs/git-conf
 
 ## Performance
 
-Benchmarked on a MacBook Pro analyzing [octobox](https://github.com/octobox/octobox) (5191 commits, 8 years of history): init takes about 18 seconds at roughly 300 commits/sec, producing an 8.3 MB database. About half the commits (2531) had dependency changes.
+Benchmarked on an M1 MacBook Pro analyzing [octobox](https://github.com/octobox/octobox) (5191 commits, 8 years of history): init takes about 18 seconds at roughly 300 commits/sec, producing an 8.3 MB database. About half the commits (2531) had dependency changes.
 
 Optimizations:
-- Bulk inserts with transaction batching (100 commits per transaction)
+- Bulk inserts with transaction batching (500 commits per transaction)
 - Blob SHA caching (75% cache hit rate for repeated manifest content)
 - Deferred index creation during bulk load
-- Sparse snapshots (every 20 dependency-changing commits) for storage efficiency
+- Sparse snapshots (every 50 dependency-changing commits) for storage efficiency
 - SQLite WAL mode for write performance
 
 ## Supported ecosystems
 
 git-pkgs uses [ecosystems-bibliothecary](https://github.com/ecosyste-ms/bibliothecary) for parsing, supporting:
 
-Actions, Anaconda, BentoML, Bower, Cargo, CocoaPods, Cog, CPAN, CRAN, CycloneDX, Docker, Dub, DVC, Elm, Go, Haxelib, Homebrew, Julia, Maven, Meteor, MLflow, npm, NuGet, Ollama, Packagist, Pub, PyPI, RubyGems, Shards, SPDX, Vcpkg
+Actions, BentoML, Bower, Cargo, CocoaPods, Cog, Conda, CPAN, CRAN, Docker, Dub, DVC, Elm, Go, Haxelib, Homebrew, Julia, Maven, Meteor, MLflow, npm, NuGet, Ollama, Packagist, Pub, PyPI, RubyGems, Shards, Vcpkg
 
-## How it works
+Some ecosystems require remote parsing services and are disabled by default: Carthage, Clojars, Hackage, Hex, SwiftPM. Enable with `git config --add pkgs.ecosystems <name>`.
 
-git-pkgs walks your git history, extracts dependency files at each commit, and diffs them to detect changes. Results are stored in a SQLite database for fast querying.
+SBOM formats (CycloneDX, SPDX) are not supported as they duplicate information from the actual lockfiles.
 
-The database schema stores:
-- Commits with dependency changes
-- Dependency changes (added/modified/removed) with before/after versions
-- Periodic snapshots of full dependency state for efficient point-in-time queries
+## Contributing
 
-See [docs/schema.md](docs/schema.md) for full schema documentation.
+Bug reports, feature requests, and pull requests are welcome. If you're unsure about a change, open an issue first to discuss it.
 
-Since the database is just SQLite, you can query it directly for ad-hoc analysis:
+Good first contributions: adding tests, improving error messages, or supporting new manifest formats via [ecosystems-bibliothecary](https://github.com/ecosyste-ms/bibliothecary).
 
-```bash
-sqlite3 .git/pkgs.sqlite3 "
-  -- who added the most dependencies?
-  SELECT c.author_name, COUNT(*) as deps_added
-  FROM dependency_changes dc
-  JOIN commits c ON dc.commit_id = c.id
-  WHERE dc.change_type = 'added'
-  GROUP BY c.author_name
-  ORDER BY deps_added DESC
-  LIMIT 10;
-"
-```
-
-## Development
-
-```bash
-git clone https://github.com/andrew/git-pkgs
-cd git-pkgs
-bin/setup
-rake test
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and architecture docs.
 
 ## License
 

data/lib/git/pkgs/analyzer.rb

@@ -24,8 +24,6 @@ module Git
         Podfile Podfile.lock *.podspec *.podspec.json
         packages.config packages.lock.json Project.json Project.lock.json
         *.nuspec paket.lock *.csproj project.assets.json
-        cyclonedx.xml cyclonedx.json *.cdx.xml *.cdx.json
-        *.spdx *.spdx.json
         bower.json bentofile.yaml
         META.json META.yml
         environment.yml environment.yaml
@@ -46,7 +44,7 @@ module Git
       QUICK_MANIFEST_REGEX = Regexp.union(
         QUICK_MANIFEST_PATTERNS.map do |pattern|
           if pattern.include?('*')
-            Regexp.new(pattern.gsub('.', '\\.').gsub('*', '.*'))
+            Regexp.new(Regexp.escape(pattern).gsub('\\*', '.*'))
           else
             /(?:^|\/)#{Regexp.escape(pattern)}$/
           end
@@ -56,6 +54,8 @@ module Git
       def initialize(repository)
         @repository = repository
         @blob_cache = {}
+        @manifest_path_cache = {}
+        Config.configure_bibliothecary
       end
 
       # Quick check if any paths might be manifests (fast regex check)
@@ -63,6 +63,23 @@ module Git
         paths.any? { |p| p.match?(QUICK_MANIFEST_REGEX) }
       end
 
+      # Cached version of Bibliothecary.identify_manifests
+      def identify_manifests_cached(paths)
+        uncached = paths.reject { |p| @manifest_path_cache.key?(p) }
+
+        if uncached.any?
+          # Call Bibliothecary only for uncached paths
+          manifests = Bibliothecary.identify_manifests(uncached)
+          manifest_set = manifests.to_set
+
+          uncached.each do |path|
+            @manifest_path_cache[path] = manifest_set.include?(path)
+          end
+        end
+
+        paths.select { |p| @manifest_path_cache[p] }
+      end
+
       # Quick check if a commit touches any manifest files
       def has_manifest_changes?(rugged_commit)
         return false if repository.merge_commit?(rugged_commit)
@@ -72,7 +89,7 @@ module Git
 
         return false unless might_have_manifests?(all_paths)
 
-        Bibliothecary.identify_manifests(all_paths).any?
+        identify_manifests_cached(all_paths).any?
       end
 
       def analyze_commit(rugged_commit, previous_snapshot = {})
@@ -87,9 +104,9 @@ module Git
         all_paths = added_paths + modified_paths + removed_paths
         return nil unless might_have_manifests?(all_paths)
 
-        added_manifests = Bibliothecary.identify_manifests(added_paths)
-        modified_manifests = Bibliothecary.identify_manifests(modified_paths)
-        removed_manifests = Bibliothecary.identify_manifests(removed_paths)
+        added_manifests = identify_manifests_cached(added_paths)
+        modified_manifests = identify_manifests_cached(modified_paths)
+        removed_manifests = identify_manifests_cached(removed_paths)
 
         return nil if added_manifests.empty? && modified_manifests.empty? && removed_manifests.empty?
 
@@ -99,7 +116,7 @@ module Git
         # Process added manifest files
         added_manifests.each do |manifest_path|
           result = parse_manifest_at_commit(rugged_commit, manifest_path)
-          next unless result
+          next unless result && result[:dependencies]
 
           result[:dependencies].each do |dep|
             changes << {
@@ -203,7 +220,7 @@ module Git
         # Process removed manifest files
         removed_manifests.each do |manifest_path|
           result = parse_manifest_before_commit(rugged_commit, manifest_path)
-          next unless result
+          next unless result && result[:dependencies]
 
           result[:dependencies].each do |dep|
             changes << {
@@ -229,9 +246,14 @@ module Git
 
       # Cache stats for debugging
       def cache_stats
-        hits = @blob_cache.values.count { |v| v[:hits] > 0 }
-        total = @blob_cache.size
-        { cached_blobs: total, blobs_with_hits: hits }
+        blob_hits = @blob_cache.values.count { |v| v[:hits] > 0 }
+        blob_total = @blob_cache.size
+        manifest_paths = @manifest_path_cache.size
+        {
+          cached_blobs: blob_total,
+          blobs_with_hits: blob_hits,
+          cached_paths: manifest_paths
+        }
       end
 
       def parse_manifest_at_commit(rugged_commit, manifest_path)
@@ -251,7 +273,7 @@ module Git
       end
 
       def parse_manifest_by_oid(blob_oid, manifest_path)
-        cache_key = "#{blob_oid}:#{manifest_path}"
+        cache_key = [blob_oid, manifest_path]
 
         if @blob_cache.key?(cache_key)
           @blob_cache[cache_key][:hits] += 1
@@ -262,6 +284,7 @@ module Git
         return nil unless content
 
         result = Bibliothecary.analyse_file(manifest_path, content).first
+        result = nil if result && Config.filter_ecosystem?(result[:platform])
         @blob_cache[cache_key] = { result: result, hits: 0 }
         result
       end

data/lib/git/pkgs/cli.rb

@@ -5,7 +5,40 @@ require "optparse"
 module Git
   module Pkgs
     class CLI
-      COMMANDS = %w[init update hooks info list tree history search why blame stale stats diff branch show log upgrade schema].freeze
+      COMMAND_GROUPS = {
+        "Setup" => {
+          "init" => "Initialize the package database for this repository",
+          "update" => "Update the database with new commits",
+          "hooks" => "Manage git hooks for auto-updating",
+          "upgrade" => "Upgrade database after git-pkgs update",
+          "info" => "Show database size and row counts",
+          "branch" => "Manage tracked branches",
+          "schema" => "Show database schema",
+          "diff-driver" => "Install git textconv driver for lockfile diffs",
+          "completions" => "Generate shell completions"
+        },
+        "Query" => {
+          "list" => "List dependencies at a commit",
+          "tree" => "Show dependency tree grouped by type",
+          "search" => "Find a dependency across all history",
+          "where" => "Show where a package appears in manifest files",
+          "why" => "Explain why a dependency exists"
+        },
+        "History" => {
+          "history" => "Show the history of a package",
+          "blame" => "Show who added each dependency",
+          "log" => "List commits with dependency changes",
+          "show" => "Show dependency changes in a commit",
+          "diff" => "Show dependency changes between commits"
+        },
+        "Analysis" => {
+          "stats" => "Show dependency statistics",
+          "stale" => "Show dependencies that haven't been updated"
+        }
+      }.freeze
+
+      COMMANDS = COMMAND_GROUPS.values.flat_map(&:keys).freeze
+      COMMAND_DESCRIPTIONS = COMMAND_GROUPS.values.reduce({}, :merge).freeze
       ALIASES = { "praise" => "blame", "outdated" => "stale" }.freeze
 
       def self.run(args)
@@ -18,6 +51,9 @@ module Git
       end
 
       def run
+        Git::Pkgs.configure_from_env
+        parse_global_options
+
         command = @args.shift
 
         case command
@@ -34,45 +70,66 @@ module Git
         end
       end
 
+      def parse_global_options
+        while @args.first&.start_with?("-")
+          arg = @args.first
+          case arg
+          when "-q", "--quiet"
+            Git::Pkgs.quiet = true
+            @args.shift
+          when /^--git-dir=(.+)$/
+            Git::Pkgs.git_dir = $1
+            @args.shift
+          when "--git-dir"
+            @args.shift
+            Git::Pkgs.git_dir = @args.shift
+          when /^--work-tree=(.+)$/
+            Git::Pkgs.work_tree = $1
+            @args.shift
+          when "--work-tree"
+            @args.shift
+            Git::Pkgs.work_tree = @args.shift
+          else
+            break
+          end
+        end
+      end
+
       def run_command(command)
         command = ALIASES.fetch(command, command)
-        command_class = Commands.const_get(command.capitalize.gsub(/_([a-z])/) { $1.upcase })
+        # Convert kebab-case or snake_case to PascalCase
+        class_name = command.split(/[-_]/).map(&:capitalize).join
+        command_class = Commands.const_get(class_name)
         command_class.new(@args).run
-      rescue NameError
+      rescue NameError => e
+        # Only catch NameError for missing command class, not NoMethodError
+        raise unless e.is_a?(NameError) && !e.is_a?(NoMethodError)
         $stderr.puts "Command '#{command}' not yet implemented"
         exit 1
       end
 
       def print_help
-        puts <<~HELP
-          Usage: git pkgs <command> [options]
+        puts "Usage: git pkgs <command> [options]"
+        puts
 
-          Commands:
-            init      Initialize the package database for this repository
-            update    Update the database with new commits
-            hooks     Manage git hooks for auto-updating
-            info      Show database size and row counts
-            branch    Manage tracked branches
-            list      List dependencies at a commit
-            tree      Show dependency tree grouped by type
-            history   Show the history of a package
-            search    Find a dependency across all history
-            why       Explain why a dependency exists
-            blame     Show who added each dependency
-            stale     Show dependencies that haven't been updated
-            stats     Show dependency statistics
-            diff      Show dependency changes between commits
-            show      Show dependency changes in a commit
-            log       List commits with dependency changes
-            upgrade   Upgrade database after git-pkgs update
-            schema    Show database schema
+        max_cmd_len = COMMANDS.map(&:length).max
 
-          Options:
-            -h, --help     Show this help message
-            -v, --version  Show version
+        COMMAND_GROUPS.each do |group, commands|
+          puts "#{group}:"
+          commands.each do |cmd, desc|
+            puts "  #{cmd.ljust(max_cmd_len)}  #{desc}"
+          end
+          puts
+        end
 
-          Run 'git pkgs <command> --help' for command-specific options.
-        HELP
+        puts "Options:"
+        puts "  -h, --help           Show this help message"
+        puts "  -v, --version        Show version"
+        puts "  -q, --quiet          Suppress informational messages"
+        puts "  --git-dir=<path>     Path to the git directory"
+        puts "  --work-tree=<path>   Path to the working tree"
+        puts
+        puts "Run 'git pkgs <command> -h' for command-specific options."
       end
     end
   end

data/lib/git/pkgs/color.rb

@@ -74,6 +74,7 @@ module Git
       def self.green(text)   = colorize(text, :green)
       def self.yellow(text)  = colorize(text, :yellow)
       def self.blue(text)    = colorize(text, :blue)
+      def self.magenta(text) = colorize(text, :magenta)
       def self.cyan(text)    = colorize(text, :cyan)
       def self.bold(text)    = colorize(text, :bold)
       def self.dim(text)     = colorize(text, :dim)

data/lib/git/pkgs/commands/blame.rb

@@ -21,7 +21,7 @@ module Git
           branch_name = @options[:branch] || repo.default_branch
           branch = Models::Branch.find_by(name: branch_name)
 
-          error "No analysis found for branch '#{branch_name}'" unless branch&.last_analyzed_sha
+          error "No analysis found for branch '#{branch_name}'. Run 'git pkgs init' first." unless branch&.last_analyzed_sha
 
           current_commit = Models::Commit.find_by(sha: branch.last_analyzed_sha)
           snapshots = current_commit&.dependency_snapshots&.includes(:manifest) || []
@@ -35,16 +35,34 @@ module Git
             return
           end
 
+          # Batch fetch all "added" changes for current dependencies
+          snapshot_keys = snapshots.map { |s| [s.name, s.manifest_id] }.to_set
+          manifest_ids = snapshots.map(&:manifest_id).uniq
+          names = snapshots.map(&:name).uniq
+
+          all_added_changes = Models::DependencyChange
+            .includes(:commit)
+            .added
+            .where(manifest_id: manifest_ids, name: names)
+            .to_a
+
+          # Group by (name, manifest_id) and find earliest by committed_at
+          added_by_key = {}
+          all_added_changes.each do |change|
+            key = [change.name, change.manifest_id]
+            next unless snapshot_keys.include?(key)
+
+            existing = added_by_key[key]
+            if existing.nil? || change.commit.committed_at < existing.commit.committed_at
+              added_by_key[key] = change
+            end
+          end
+
           # For each current dependency, find who added it
           blame_data = []
 
           snapshots.each do |snapshot|
-            added_change = Models::DependencyChange
-              .includes(:commit)
-              .where(name: snapshot.name, manifest: snapshot.manifest)
-              .added
-              .order("commits.committed_at ASC")
-              .first
+            added_change = added_by_key[[snapshot.name, snapshot.manifest_id]]
 
             next unless added_change
 
@@ -101,7 +119,7 @@ module Git
         def parse_coauthors(message)
           return [] unless message
 
-          message.scan(/^Co-authored-by:\s*(.+?)\s*<[^>]+>/i).flatten
+          message.scan(/^Co-authored-by:([^<]+)<[^>]+>/i).flatten.map(&:strip)
         end
 
         def bot_author?(name)

data/lib/git/pkgs/commands/branch.rb

@@ -6,8 +6,16 @@ module Git
       class Branch
         include Output
 
-        BATCH_SIZE = 100
-        SNAPSHOT_INTERVAL = 20
+        DEFAULT_BATCH_SIZE = 500
+        DEFAULT_SNAPSHOT_INTERVAL = 50
+
+        def batch_size
+          Git::Pkgs.batch_size || DEFAULT_BATCH_SIZE
+        end
+
+        def snapshot_interval
+          Git::Pkgs.snapshot_interval || DEFAULT_SNAPSHOT_INTERVAL
+        end
 
         def initialize(args)
           @args = args
@@ -40,12 +48,12 @@ module Git
 
           Database.connect(repo.git_dir)
 
-          error "Branch '#{branch_name}' not found" unless repo.branch_exists?(branch_name)
+          error "Branch '#{branch_name}' not found. Check 'git branch -a' for available branches." unless repo.branch_exists?(branch_name)
 
           existing = Models::Branch.find_by(name: branch_name)
           if existing
-            puts "Branch '#{branch_name}' already tracked (#{existing.commits.count} commits)"
-            puts "Use 'git pkgs update' to refresh"
+            info "Branch '#{branch_name}' already tracked (#{existing.commits.count} commits)"
+            info "Use 'git pkgs update' to refresh"
             return
           end
 
@@ -54,11 +62,15 @@ module Git
           branch = Models::Branch.create!(name: branch_name)
           analyzer = Analyzer.new(repo)
 
-          puts "Analyzing branch: #{branch_name}"
+          info "Analyzing branch: #{branch_name}"
 
+          print "Loading commits..." unless Git::Pkgs.quiet
           walker = repo.walk(branch_name)
           commits = walker.to_a
           total = commits.size
+          print "\rPrefetching diffs..." unless Git::Pkgs.quiet
+          repo.prefetch_blob_paths(commits)
+          print "\r#{' ' * 20}\r" unless Git::Pkgs.quiet
 
           stats = bulk_process_commits(commits, branch, analyzer, total, repo)
 
@@ -66,10 +78,10 @@ module Git
 
           Database.optimize_for_reads
 
-          puts "\rDone!#{' ' * 20}"
-          puts "Analyzed #{total} commits"
-          puts "Found #{stats[:dependency_commits]} commits with dependency changes"
-          puts "Stored #{stats[:snapshots_stored]} snapshots"
+          info "\rDone!#{' ' * 20}"
+          info "Analyzed #{total} commits"
+          info "Found #{stats[:dependency_commits]} commits with dependency changes"
+          info "Stored #{stats[:snapshots_stored]} snapshots"
         end
 
         def list_branches
@@ -104,14 +116,14 @@ module Git
           Database.connect(repo.git_dir)
 
           branch = Models::Branch.find_by(name: branch_name)
-          error "Branch '#{branch_name}' not tracked" unless branch
+          error "Branch '#{branch_name}' not tracked. Run 'git pkgs branch list' to see tracked branches." unless branch
 
           # Only delete branch_commits, keep shared commits
           count = branch.branch_commits.count
           branch.branch_commits.delete_all
           branch.destroy
 
-          puts "Removed branch '#{branch_name}' (#{count} branch-commit links)"
+          info "Removed branch '#{branch_name}' (#{count} branch-commit links)"
         end
 
         def bulk_process_commits(commits, branch, analyzer, total, repo)
@@ -196,7 +208,7 @@ module Git
 
           commits.each do |rugged_commit|
             processed += 1
-            print "\rProcessing commit #{processed}/#{total}..." if processed % 50 == 0 || processed == total
+            print "\rProcessing commit #{processed}/#{total}..." if !Git::Pkgs.quiet && (processed % 50 == 0 || processed == total)
 
             next if rugged_commit.parents.length > 1
 
@@ -247,7 +259,7 @@ module Git
 
               snapshot = result[:snapshot]
 
-              if dependency_commit_count % SNAPSHOT_INTERVAL == 0
+              if dependency_commit_count % snapshot_interval == 0
                 snapshot.each do |(manifest_path, name), dep_info|
                   pending_snapshots << {
                     sha: rugged_commit.oid,
@@ -262,7 +274,7 @@ module Git
               end
             end
 
-            flush.call if pending_commits.size >= BATCH_SIZE
+            flush.call if pending_commits.size >= batch_size
           end
 
           if snapshot.any?