git-pkgs 0.5.0 → 0.6.1

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

@@ -23,19 +23,19 @@ module Git
 
           # Search for dependencies matching the pattern
           query = Models::DependencyChange
-            .joins(:manifest)
-            .where("dependency_changes.name LIKE ?", "%#{pattern}%")
+            .join(:manifests, id: :manifest_id)
+            .where(Sequel.like(Sequel[:dependency_changes][:name], "%#{pattern}%"))
 
           if @options[:ecosystem]
-            query = query.where(ecosystem: @options[:ecosystem])
+            query = query.where(Sequel[:dependency_changes][:ecosystem] => @options[:ecosystem])
           end
 
           if @options[:direct]
-            query = query.where(manifests: { kind: "manifest" })
+            query = query.where(Sequel[:manifests][:kind] => "manifest")
           end
 
           # Get unique dependency names
-          matches = query.distinct.pluck(:name, :ecosystem)
+          matches = query.distinct.select_map([Sequel[:dependency_changes][:name], Sequel[:dependency_changes][:ecosystem]])
 
           if matches.empty?
             empty_result "No dependencies found matching '#{pattern}'"
@@ -70,12 +70,14 @@ module Git
           results = matches.map do |name, platform|
             changes = Models::DependencyChange
               .where(name: name, ecosystem: platform)
-              .includes(:commit)
-              .order("commits.committed_at ASC")
+              .eager(:commit)
+              .association_join(:commit)
+              .order(Sequel[:commit][:committed_at])
+              .all
 
             first = changes.first
             last = changes.last
-            current = changes.where(change_type: %w[added modified]).last
+            current = changes.select { |c| %w[added modified].include?(c.change_type) }.last
 
             {
               name: name,
@@ -94,8 +96,10 @@ module Git
         def dependency_summary(name, platform)
           changes = Models::DependencyChange
             .where(name: name, ecosystem: platform)
-            .includes(:commit)
-            .order("commits.committed_at ASC")
+            .eager(:commit)
+            .association_join(:commit)
+            .order(Sequel[:commit][:committed_at])
+            .all
 
           first = changes.first
           last = changes.last
@@ -106,7 +110,7 @@ module Git
           if last.change_type == "removed"
             parts << "removed #{last.commit.committed_at.strftime('%Y-%m-%d')}"
           else
-            current = changes.where(change_type: %w[added modified]).last
+            current = changes.select { |c| %w[added modified].include?(c.change_type) }.last
             parts << "current: #{current&.requirement || 'unknown'}"
           end
 

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

@@ -26,13 +26,15 @@ module Git
           error "Commit '#{sha[0..7]}' not in database. Run 'git pkgs update' to index new commits." unless commit
 
           changes = Models::DependencyChange
-            .includes(:commit, :manifest)
+            .eager(:commit, :manifest)
             .where(commit_id: commit.id)
 
           if @options[:ecosystem]
             changes = changes.where(ecosystem: @options[:ecosystem])
           end
 
+          changes = changes.all
+
           if changes.empty?
             empty_result "No dependency changes in #{commit.short_sha}"
             return

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

@@ -18,17 +18,22 @@ module Git
           Database.connect(repo.git_dir)
 
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
 
           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) || []
+          current_commit = Models::Commit.first(sha: branch.last_analyzed_sha)
+
+          return empty_result("No dependencies found") unless current_commit
+
+          snapshots = current_commit.dependency_snapshots_dataset.eager(:manifest)
 
           if @options[:ecosystem]
             snapshots = snapshots.where(ecosystem: @options[:ecosystem])
           end
 
+          snapshots = snapshots.all
+
           if snapshots.empty?
             empty_result "No dependencies found"
             return
@@ -40,7 +45,7 @@ module Git
           names = snapshots.map(&:name).uniq
 
           all_changes = Models::DependencyChange
-            .includes(:commit)
+            .eager(:commit)
             .where(manifest_id: manifest_ids, name: names)
             .to_a
 

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

@@ -18,7 +18,7 @@ module Git
           Database.connect(repo.git_dir)
 
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
 
           if @options[:by_author]
             output_by_author
@@ -39,9 +39,9 @@ module Git
           since_time = @options[:since] ? parse_time(@options[:since]) : nil
           until_time = @options[:until] ? parse_time(@options[:until]) : nil
 
-          commits = branch&.commits || Models::Commit.none
-          commits = commits.where("committed_at >= ?", since_time) if since_time
-          commits = commits.where("committed_at <= ?", until_time) if until_time
+          commits = branch ? branch.commits_dataset : Models::Commit.where(false)
+          commits = commits.where { committed_at >= since_time } if since_time
+          commits = commits.where { committed_at <= until_time } if until_time
 
           data = {
             branch: branch_name,
@@ -57,52 +57,63 @@ module Git
           }
 
           if branch&.last_analyzed_sha
-            current_commit = Models::Commit.find_by(sha: branch.last_analyzed_sha)
-            snapshots = current_commit&.dependency_snapshots || []
+            current_commit = Models::Commit.first(sha: branch.last_analyzed_sha)
+            snapshots = current_commit ? current_commit.dependency_snapshots_dataset : Models::DependencySnapshot.where(false)
             snapshots = snapshots.where(ecosystem: ecosystem) if ecosystem
 
             data[:current_dependencies] = {
               total: snapshots.count,
-              by_platform: snapshots.group(:ecosystem).count,
-              by_type: snapshots.group(:dependency_type).count
+              by_platform: snapshots.group_and_count(:ecosystem).as_hash(:ecosystem, :count),
+              by_type: snapshots.group_and_count(:dependency_type).as_hash(:dependency_type, :count)
             }
           end
 
-          changes = Models::DependencyChange.joins(:commit)
-          changes = changes.where(ecosystem: ecosystem) if ecosystem
-          changes = changes.where("commits.committed_at >= ?", since_time) if since_time
-          changes = changes.where("commits.committed_at <= ?", until_time) if until_time
+          changes = Models::DependencyChange.join(:commits, id: :commit_id)
+          changes = changes.where(Sequel[:dependency_changes][:ecosystem] => ecosystem) if ecosystem
+          changes = changes.where { Sequel[:commits][:committed_at] >= since_time } if since_time
+          changes = changes.where { Sequel[:commits][:committed_at] <= until_time } if until_time
 
           data[:changes] = {
             total: changes.count,
-            by_type: changes.group(:change_type).count
+            by_type: changes.group_and_count(Sequel[:dependency_changes][:change_type]).as_hash(:change_type, :count)
           }
 
           most_changed = changes
-            .group(:name, :ecosystem)
-            .order("count_all DESC")
+            .select(Sequel[:dependency_changes][:name], Sequel[:dependency_changes][:ecosystem])
+            .select_append { count.function.*.as(:change_count) }
+            .group(Sequel[:dependency_changes][:name], Sequel[:dependency_changes][:ecosystem])
+            .order(Sequel.desc(:change_count))
             .limit(10)
-            .count
+            .all
 
-          data[:most_changed] = most_changed.map do |(name, eco), count|
-            { name: name, ecosystem: eco, changes: count }
+          data[:most_changed] = most_changed.map do |row|
+            { name: row[:name], ecosystem: row[:ecosystem], changes: row[:change_count] }
           end
 
-          manifests = Models::Manifest.all
+          manifests = Models::Manifest.dataset
           manifests = manifests.where(ecosystem: ecosystem) if ecosystem
 
-          manifest_ids = manifests.pluck(:id)
+          manifest_ids = manifests.select_map(:id)
           change_counts_query = Models::DependencyChange
-            .joins(:commit)
-            .where(manifest_id: manifest_ids)
-          change_counts_query = change_counts_query.where("commits.committed_at >= ?", since_time) if since_time
-          change_counts_query = change_counts_query.where("commits.committed_at <= ?", until_time) if until_time
-          change_counts = change_counts_query.group(:manifest_id).count
+            .join(:commits, id: :commit_id)
+            .where(Sequel[:dependency_changes][:manifest_id] => manifest_ids)
+          change_counts_query = change_counts_query.where { Sequel[:commits][:committed_at] >= since_time } if since_time
+          change_counts_query = change_counts_query.where { Sequel[:commits][:committed_at] <= until_time } if until_time
+          change_counts = change_counts_query.group_and_count(Sequel[:dependency_changes][:manifest_id]).as_hash(:manifest_id, :count)
 
-          data[:manifests] = manifests.map do |manifest|
+          data[:manifests] = manifests.all.map do |manifest|
             { path: manifest.path, ecosystem: manifest.ecosystem, changes: change_counts[manifest.id] || 0 }
           end
 
+          top_authors = changes
+            .where(Sequel[:dependency_changes][:change_type] => "added")
+            .group_and_count(Sequel[:commits][:author_name])
+            .order(Sequel.desc(:count))
+            .limit(5)
+            .as_hash(:author_name, :count)
+
+          data[:top_authors] = top_authors.map { |name, count| { name: name, added: count } }
+
           data
         end
 
@@ -159,6 +170,15 @@ module Git
           data[:manifests].each do |m|
             puts "  #{m[:path]} (#{m[:ecosystem]}): #{m[:changes]} changes"
           end
+
+          if data[:top_authors]&.any?
+            puts
+            puts "Top Authors (by deps added)"
+            puts "-" * 27
+            data[:top_authors].each do |author|
+              puts "  #{author[:added].to_s.rjust(4)}  #{author[:name]}"
+            end
+          end
         end
 
         def output_by_author
@@ -166,18 +186,18 @@ module Git
           until_time = @options[:until] ? parse_time(@options[:until]) : nil
 
           changes = Models::DependencyChange
-            .joins(:commit)
-            .where(change_type: "added")
+            .join(:commits, id: :commit_id)
+            .where(Sequel[:dependency_changes][:change_type] => "added")
 
-          changes = changes.where(ecosystem: @options[:ecosystem]) if @options[:ecosystem]
-          changes = changes.where("commits.committed_at >= ?", since_time) if since_time
-          changes = changes.where("commits.committed_at <= ?", until_time) if until_time
+          changes = changes.where(Sequel[:dependency_changes][:ecosystem] => @options[:ecosystem]) if @options[:ecosystem]
+          changes = changes.where { Sequel[:commits][:committed_at] >= since_time } if since_time
+          changes = changes.where { Sequel[:commits][:committed_at] <= until_time } if until_time
 
           counts = changes
-            .group("commits.author_name")
-            .order("count_all DESC")
+            .group_and_count(Sequel[:commits][:author_name])
+            .order(Sequel.desc(:count))
             .limit(@options[:limit] || 20)
-            .count
+            .as_hash(:author_name, :count)
 
           if counts.empty?
             empty_result "No dependency additions found"

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

@@ -24,21 +24,23 @@ module Git
           error "No dependency data for commit #{commit_sha[0, 7]}. Run 'git pkgs update' to index new commits." unless commit
 
           # Get current snapshots
-          snapshots = commit.dependency_snapshots.includes(:manifest)
+          snapshots = commit.dependency_snapshots_dataset.eager(:manifest)
 
           if @options[:ecosystem]
             snapshots = snapshots.where(ecosystem: @options[:ecosystem])
           end
 
-          if snapshots.empty?
+          snapshots_list = snapshots.all
+
+          if snapshots_list.empty?
             empty_result "No dependencies found"
             return
           end
 
           # Group by manifest and build tree
-          grouped = snapshots.group_by { |s| s.manifest }
+          grouped = snapshots_list.group_by { |s| s.manifest }
 
-          paginate { output_text(grouped, snapshots) }
+          paginate { output_text(grouped, snapshots_list) }
         end
 
         def output_text(grouped, snapshots)
@@ -73,19 +75,20 @@ module Git
         end
 
         def find_commit_with_snapshot(sha, repo)
-          commit = Models::Commit.find_by(sha: sha) ||
-                   Models::Commit.where("sha LIKE ?", "#{sha}%").first
+          commit = Models::Commit.first(sha: sha) ||
+                   Models::Commit.where(Sequel.like(:sha, "#{sha}%")).first
           return commit if commit&.dependency_snapshots&.any?
 
           # Find most recent commit with a snapshot
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
           return nil unless branch
 
-          branch.commits
-            .joins(:dependency_snapshots)
-            .where("commits.committed_at <= ?", commit&.committed_at || Time.now)
-            .order(committed_at: :desc)
+          target_time = commit&.committed_at || Time.now
+          branch.commits_dataset
+            .join(:dependency_snapshots, commit_id: :id)
+            .where { Sequel[:commits][:committed_at] <= target_time }
+            .order(Sequel.desc(Sequel[:commits][:committed_at]))
             .distinct
             .first
         end

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

@@ -18,7 +18,7 @@ module Git
           Database.connect(repo.git_dir)
 
           branch_name = @options[:branch] || repo.default_branch
-          branch = Models::Branch.find_by(name: branch_name)
+          branch = Models::Branch.first(name: branch_name)
 
           error "Branch '#{branch_name}' not in database. Run 'git pkgs init --branch=#{branch_name}' first." unless branch
 
@@ -33,11 +33,11 @@ module Git
           analyzer = Analyzer.new(repo)
 
           # Get current snapshot from last analyzed commit
-          last_commit = Models::Commit.find_by(sha: since_sha)
+          last_commit = Models::Commit.first(sha: since_sha)
           snapshot = {}
 
           if last_commit
-            last_commit.dependency_snapshots.includes(:manifest).each do |s|
+            last_commit.dependency_snapshots.each do |s|
               key = [s.manifest.path, s.name]
               snapshot[key] = {
                 ecosystem: s.ecosystem,
@@ -54,24 +54,23 @@ module Git
 
           processed = 0
           dependency_commits = 0
-          last_position = Models::BranchCommit.where(branch: branch).maximum(:position) || 0
+          last_position = Models::BranchCommit.where(branch: branch).max(:position) || 0
 
-          info "Updating branch: #{branch_name}"
-          info "Found #{total} new commits"
+          print "Updating #{branch_name}..." unless Git::Pkgs.quiet
 
-          ActiveRecord::Base.transaction do
+          Database.db.transaction do
             commits.each do |rugged_commit|
               processed += 1
-              print "\rProcessing commit #{processed}/#{total}..." unless Git::Pkgs.quiet
 
               result = analyzer.analyze_commit(rugged_commit, snapshot)
 
               commit = Models::Commit.find_or_create_from_rugged(rugged_commit)
-              Models::BranchCommit.find_or_create_by(
+              Models::BranchCommit.find_or_create(
                 branch: branch,
-                commit: commit,
-                position: last_position + processed
-              )
+                commit: commit
+              ) do |bc|
+                bc.position = last_position + processed
+              end
 
               if result && result[:changes].any?
                 dependency_commits += 1
@@ -84,7 +83,7 @@ module Git
                     kind: change[:kind]
                   )
 
-                  Models::DependencyChange.create!(
+                  Models::DependencyChange.create(
                     commit: commit,
                     manifest: manifest,
                     name: change[:name],
@@ -99,8 +98,8 @@ module Git
                 snapshot = result[:snapshot]
 
                 snapshot.each do |(manifest_path, name), dep_info|
-                  manifest = Models::Manifest.find_by(path: manifest_path)
-                  Models::DependencySnapshot.find_or_create_by(
+                  manifest = Models::Manifest.first(path: manifest_path)
+                  Models::DependencySnapshot.find_or_create(
                     commit: commit,
                     manifest: manifest,
                     name: name
@@ -116,9 +115,7 @@ module Git
             branch.update(last_analyzed_sha: current_sha)
           end
 
-          info "\nDone!"
-          info "Processed #{total} new commits"
-          info "Found #{dependency_commits} commits with dependency changes"
+          info "\r#{' ' * 40}\rUpdated #{branch_name}: #{total} commits (#{dependency_commits} with dependency changes)"
         end
 
         def parse_options

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

@@ -22,7 +22,7 @@ module Git
           Database.connect(repo.git_dir)
 
           workdir = File.dirname(repo.git_dir)
-          branch = Models::Branch.find_by(name: @options[:branch] || repo.default_branch)
+          branch = Models::Branch.first(name: @options[:branch] || repo.default_branch)
 
           unless branch
             error "Branch not found. Run 'git pkgs init' first."
@@ -31,7 +31,10 @@ module Git
           snapshots = Models::DependencySnapshot.current_for_branch(branch)
           snapshots = snapshots.where(ecosystem: @options[:ecosystem]) if @options[:ecosystem]
 
-          manifest_paths = snapshots.for_package(name).joins(:manifest).pluck("manifests.path").uniq
+          manifest_paths = snapshots.for_package(name)
+            .join(:manifests, id: :manifest_id)
+            .select_map(Sequel[:manifests][:path])
+            .uniq
 
           if manifest_paths.empty?
             empty_result "Package '#{name}' not found in current dependencies"

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

@@ -23,7 +23,7 @@ module Git
 
           # Find the first time this package was added
           added_change = Models::DependencyChange
-            .includes(:commit, :manifest)
+            .eager(:commit, :manifest)
             .for_package(package_name)
             .added
             .order("commits.committed_at ASC")

data/lib/git/pkgs/config.rb

@@ -5,9 +5,6 @@ require "bibliothecary"
 module Git
   module Pkgs
     module Config
-      # Ecosystems that require remote parsing services - disabled by default
-      REMOTE_ECOSYSTEMS = %w[carthage clojars hackage hex swiftpm].freeze
-
       # File patterns ignored by default (SBOM formats not supported)
       DEFAULT_IGNORED_FILES = %w[
         cyclonedx.xml
@@ -41,24 +38,12 @@ module Git
       end
 
       def self.filter_ecosystem?(platform)
-        platform_lower = platform.to_s.downcase
-
-        # Remote ecosystems are disabled unless explicitly enabled
-        if REMOTE_ECOSYSTEMS.include?(platform_lower)
-          return !ecosystems.map(&:downcase).include?(platform_lower)
-        end
-
-        # If no filter configured, allow all non-remote ecosystems
         return false if ecosystems.empty?
 
-        # Otherwise, only allow explicitly listed ecosystems
+        platform_lower = platform.to_s.downcase
         !ecosystems.map(&:downcase).include?(platform_lower)
       end
 
-      def self.remote_ecosystem?(platform)
-        REMOTE_ECOSYSTEMS.include?(platform.to_s.downcase)
-      end
-
       def self.reset!
         @ignored_dirs = nil
         @ignored_files = nil