git-pkgs 0.2.0 → 0.3.0

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

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Git
   module Pkgs
     module Commands
       class Stats
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -11,11 +15,7 @@ module Git
 
         def run
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           Database.connect(repo.git_dir)
 
@@ -31,19 +31,27 @@ module Git
               require "json"
               puts JSON.pretty_generate(data)
             else
-              output_text(data)
+              paginate { output_text(data) }
             end
           end
         end
 
         def collect_stats(branch, branch_name)
           ecosystem = @options[:ecosystem]
+          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
 
           data = {
             branch: branch_name,
             ecosystem: ecosystem,
-            commits_analyzed: branch&.commits&.count || 0,
-            commits_with_changes: branch&.commits&.where(has_dependency_changes: true)&.count || 0,
+            since: @options[:since],
+            until: @options[:until],
+            commits_analyzed: commits.count,
+            commits_with_changes: commits.where(has_dependency_changes: true).count,
             current_dependencies: {},
             changes: {},
             most_changed: [],
@@ -62,8 +70,10 @@ module Git
             }
           end
 
-          changes = Models::DependencyChange.all
+          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
 
           data[:changes] = {
             total: changes.count,
@@ -84,7 +94,10 @@ module Git
           manifests = manifests.where(ecosystem: ecosystem) if ecosystem
 
           data[:manifests] = manifests.map do |manifest|
-            { path: manifest.path, ecosystem: manifest.ecosystem, changes: manifest.dependency_changes.count }
+            manifest_changes = manifest.dependency_changes.joins(:commit)
+            manifest_changes = manifest_changes.where("commits.committed_at >= ?", since_time) if since_time
+            manifest_changes = manifest_changes.where("commits.committed_at <= ?", until_time) if until_time
+            { path: manifest.path, ecosystem: manifest.ecosystem, changes: manifest_changes.count }
           end
 
           data
@@ -97,6 +110,8 @@ module Git
 
           puts "Branch: #{data[:branch]}"
           puts "Ecosystem: #{data[:ecosystem]}" if data[:ecosystem]
+          puts "Since: #{data[:since]}" if data[:since]
+          puts "Until: #{data[:until]}" if data[:until]
           puts "Commits analyzed: #{data[:commits_analyzed]}"
           puts "Commits with changes: #{data[:commits_with_changes]}"
           puts
@@ -144,11 +159,16 @@ module Git
         end
 
         def output_by_author
+          since_time = @options[:since] ? parse_time(@options[:since]) : nil
+          until_time = @options[:until] ? parse_time(@options[:until]) : nil
+
           changes = Models::DependencyChange
             .joins(:commit)
             .where(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
 
           counts = changes
             .group("commits.author_name")
@@ -157,7 +177,7 @@ module Git
             .count
 
           if counts.empty?
-            puts "No dependency additions found"
+            empty_result "No dependency additions found"
             return
           end
 
@@ -166,15 +186,25 @@ module Git
             data = counts.map { |name, count| { author: name, added: count } }
             puts JSON.pretty_generate(data)
           else
-            puts "Dependencies Added by Author"
-            puts "=" * 40
-            puts
-            counts.each do |name, count|
-              puts "  #{count.to_s.rjust(4)}  #{name}"
-            end
+            paginate { output_by_author_text(counts) }
+          end
+        end
+
+        def output_by_author_text(counts)
+          puts "Dependencies Added by Author"
+          puts "=" * 40
+          puts
+          counts.each do |name, count|
+            puts "  #{count.to_s.rjust(4)}  #{name}"
           end
         end
 
+        def parse_time(str)
+          Time.parse(str)
+        rescue ArgumentError
+          error "Invalid date format: #{str}"
+        end
+
         def parse_options
           options = {}
 
@@ -193,6 +223,14 @@ module Git
               options[:format] = v
             end
 
+            opts.on("--since=DATE", "Show changes after date") do |v|
+              options[:since] = v
+            end
+
+            opts.on("--until=DATE", "Show changes before date") do |v|
+              options[:until] = v
+            end
+
             opts.on("--by-author", "Show dependencies added by author") do
               options[:by_author] = true
             end
@@ -201,6 +239,10 @@ module Git
               options[:limit] = v
             end
 
+            opts.on("--no-pager", "Do not pipe output into a pager") do
+              options[:no_pager] = true
+            end
+
             opts.on("-h", "--help", "Show this help") do
               puts opts
               exit

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Tree
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -11,11 +13,7 @@ module Git
 
         def run
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           Database.connect(repo.git_dir)
 
@@ -23,10 +21,7 @@ module Git
           commit_sha = @options[:commit] || repo.head_sha
           commit = find_commit_with_snapshot(commit_sha, repo)
 
-          unless commit
-            $stderr.puts "No dependency data found for commit #{commit_sha[0, 7]}"
-            exit 1
-          end
+          error "No dependency data found for commit #{commit_sha[0, 7]}" unless commit
 
           # Get current snapshots
           snapshots = commit.dependency_snapshots.includes(:manifest)
@@ -36,13 +31,17 @@ module Git
           end
 
           if snapshots.empty?
-            puts "No dependencies found"
+            empty_result "No dependencies found"
             return
           end
 
           # Group by manifest and build tree
           grouped = snapshots.group_by { |s| s.manifest }
 
+          paginate { output_text(grouped, snapshots) }
+        end
+
+        def output_text(grouped, snapshots)
           grouped.each do |manifest, deps|
             puts "#{manifest.path} (#{manifest.ecosystem})"
             puts
@@ -109,6 +108,10 @@ module Git
               options[:branch] = v
             end
 
+            opts.on("--no-pager", "Do not pipe output into a pager") do
+              options[:no_pager] = true
+            end
+
             opts.on("-h", "--help", "Show this help") do
               puts opts
               exit

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Update
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -11,21 +13,14 @@ module Git
 
         def run
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           Database.connect(repo.git_dir)
 
           branch_name = @options[:branch] || repo.default_branch
           branch = Models::Branch.find_by(name: branch_name)
 
-          unless branch
-            $stderr.puts "Branch '#{branch_name}' not in database. Run 'git pkgs init --branch=#{branch_name}' first."
-            exit 1
-          end
+          error "Branch '#{branch_name}' not in database. Run 'git pkgs init --branch=#{branch_name}' first." unless branch
 
           since_sha = branch.last_analyzed_sha
           current_sha = repo.branch_target(branch_name)
@@ -62,60 +57,62 @@ module Git
           puts "Updating branch: #{branch_name}"
           puts "Found #{total} new commits"
 
-          commits.each do |rugged_commit|
-            processed += 1
-            print "\rProcessing commit #{processed}/#{total}..."
-
-            result = analyzer.analyze_commit(rugged_commit, snapshot)
-
-            commit = Models::Commit.find_or_create_from_rugged(rugged_commit)
-            Models::BranchCommit.find_or_create_by(
-              branch: branch,
-              commit: commit,
-              position: last_position + processed
-            )
-
-            if result && result[:changes].any?
-              dependency_commits += 1
-              commit.update(has_dependency_changes: true)
-
-              result[:changes].each do |change|
-                manifest = Models::Manifest.find_or_create(
-                  path: change[:manifest_path],
-                  ecosystem: change[:ecosystem],
-                  kind: change[:kind]
-                )
-
-                Models::DependencyChange.create!(
-                  commit: commit,
-                  manifest: manifest,
-                  name: change[:name],
-                  ecosystem: change[:ecosystem],
-                  change_type: change[:change_type],
-                  requirement: change[:requirement],
-                  previous_requirement: change[:previous_requirement],
-                  dependency_type: change[:dependency_type]
-                )
-              end
+          ActiveRecord::Base.transaction do
+            commits.each do |rugged_commit|
+              processed += 1
+              print "\rProcessing commit #{processed}/#{total}..."
+
+              result = analyzer.analyze_commit(rugged_commit, snapshot)
+
+              commit = Models::Commit.find_or_create_from_rugged(rugged_commit)
+              Models::BranchCommit.find_or_create_by(
+                branch: branch,
+                commit: commit,
+                position: last_position + processed
+              )
+
+              if result && result[:changes].any?
+                dependency_commits += 1
+                commit.update(has_dependency_changes: true)
+
+                result[:changes].each do |change|
+                  manifest = Models::Manifest.find_or_create(
+                    path: change[:manifest_path],
+                    ecosystem: change[:ecosystem],
+                    kind: change[:kind]
+                  )
+
+                  Models::DependencyChange.create!(
+                    commit: commit,
+                    manifest: manifest,
+                    name: change[:name],
+                    ecosystem: change[:ecosystem],
+                    change_type: change[:change_type],
+                    requirement: change[:requirement],
+                    previous_requirement: change[:previous_requirement],
+                    dependency_type: change[:dependency_type]
+                  )
+                end
 
-              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(
-                  commit: commit,
-                  manifest: manifest,
-                  name: name
-                ) do |s|
-                  s.ecosystem = dep_info[:ecosystem]
-                  s.requirement = dep_info[:requirement]
-                  s.dependency_type = dep_info[:dependency_type]
+                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(
+                    commit: commit,
+                    manifest: manifest,
+                    name: name
+                  ) do |s|
+                    s.ecosystem = dep_info[:ecosystem]
+                    s.requirement = dep_info[:requirement]
+                    s.dependency_type = dep_info[:dependency_type]
+                  end
                 end
               end
             end
-          end
 
-          branch.update(last_analyzed_sha: current_sha)
+            branch.update(last_analyzed_sha: current_sha)
+          end
 
           puts "\nDone!"
           puts "Processed #{total} new commits"

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Upgrade
+        include Output
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+          require_database(repo)
+
+          Database.connect(repo.git_dir, check_version: false)
+
+          stored = Database.stored_version || 0
+          current = Database::SCHEMA_VERSION
+
+          if stored >= current
+            puts "Database is up to date (version #{current})"
+            return
+          end
+
+          puts "Upgrading database from version #{stored} to #{current}..."
+          puts "This requires re-indexing the repository."
+          puts
+
+          # Run init --force
+          Init.new(["--force"]).run
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs upgrade [options]"
+
+            opts.on("-h", "--help", "Show this help") do
+              puts opts
+              exit
+            end
+          end
+
+          parser.parse!(@args)
+          options
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Why
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -12,17 +14,10 @@ module Git
         def run
           package_name = @args.shift
 
-          unless package_name
-            $stderr.puts "Usage: git pkgs why <package>"
-            exit 1
-          end
+          error "Usage: git pkgs why <package>" unless package_name
 
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           Database.connect(repo.git_dir)
 
@@ -40,7 +35,7 @@ module Git
           added_change = added_change.first
 
           unless added_change
-            puts "Package '#{package_name}' not found in dependency history"
+            empty_result "Package '#{package_name}' not found in dependency history"
             return
           end
 

data/lib/git/pkgs/database.rb

@@ -7,13 +7,24 @@ module Git
   module Pkgs
     class Database
       DB_FILE = "pkgs.sqlite3"
+      SCHEMA_VERSION = 1
 
       def self.path(git_dir = nil)
+        return ENV["GIT_PKGS_DB"] if ENV["GIT_PKGS_DB"] && !ENV["GIT_PKGS_DB"].empty?
+
         git_dir ||= find_git_dir
         File.join(git_dir, DB_FILE)
       end
 
       def self.find_git_dir
+        # Respect GIT_DIR environment variable
+        if ENV["GIT_DIR"] && !ENV["GIT_DIR"].empty?
+          git_dir = ENV["GIT_DIR"]
+          return git_dir if File.directory?(git_dir)
+
+          raise NotInGitRepoError, "GIT_DIR '#{git_dir}' does not exist"
+        end
+
         dir = Dir.pwd
         loop do
           git_dir = File.join(dir, ".git")
@@ -26,12 +37,13 @@ module Git
         end
       end
 
-      def self.connect(git_dir = nil)
+      def self.connect(git_dir = nil, check_version: true)
         db_path = path(git_dir)
         ActiveRecord::Base.establish_connection(
           adapter: "sqlite3",
           database: db_path
         )
+        check_version! if check_version
       end
 
       def self.connect_memory
@@ -48,6 +60,10 @@ module Git
 
       def self.create_schema(with_indexes: true)
         ActiveRecord::Schema.define do
+          create_table :schema_info, if_not_exists: true do |t|
+            t.integer :version, null: false
+          end
+
           create_table :branches, if_not_exists: true do |t|
             t.string :name, null: false
             t.string :last_analyzed_sha
@@ -104,6 +120,7 @@ module Git
           end
         end
 
+        set_version
         create_bulk_indexes if with_indexes
       end
 
@@ -122,6 +139,43 @@ module Git
         conn.add_index :dependency_snapshots, :ecosystem, if_not_exists: true
       end
 
+      def self.stored_version
+        conn = ActiveRecord::Base.connection
+        return nil unless conn.table_exists?(:schema_info)
+
+        result = conn.select_value("SELECT version FROM schema_info LIMIT 1")
+        result&.to_i
+      end
+
+      def self.set_version(version = SCHEMA_VERSION)
+        conn = ActiveRecord::Base.connection
+        conn.execute("DELETE FROM schema_info")
+        conn.execute("INSERT INTO schema_info (version) VALUES (#{version})")
+      end
+
+      def self.needs_upgrade?
+        conn = ActiveRecord::Base.connection
+
+        # No tables at all = fresh database, no upgrade needed
+        return false unless conn.table_exists?(:commits)
+
+        # Has commits table but no schema_info = old database, needs upgrade
+        return true unless conn.table_exists?(:schema_info)
+
+        # Check version
+        stored = stored_version || 0
+        stored < SCHEMA_VERSION
+      end
+
+      def self.check_version!
+        return unless needs_upgrade?
+
+        stored = stored_version || 0
+        $stderr.puts "Database schema is outdated (version #{stored}, current is #{SCHEMA_VERSION})."
+        $stderr.puts "Run 'git pkgs upgrade' to update."
+        exit 1
+      end
+
       def self.optimize_for_bulk_writes
         conn = ActiveRecord::Base.connection
         conn.execute("PRAGMA synchronous = OFF")

data/lib/git/pkgs/output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "pager"
+
+module Git
+  module Pkgs
+    module Output
+      include Pager
+      # Print error message and exit with code 1.
+      # Use for user errors (bad input, invalid refs) and system errors (db missing).
+      # When format is :json, outputs JSON to stdout; otherwise outputs text to stderr.
+      def error(msg, format: nil)
+        format ||= @options[:format] if defined?(@options) && @options.is_a?(Hash)
+
+        if format == "json"
+          puts JSON.generate({ error: msg })
+        else
+          $stderr.puts msg
+        end
+        exit 1
+      end
+
+      # Print informational message for "no results" cases.
+      # When format is :json, outputs empty JSON array/object; otherwise outputs text.
+      def empty_result(msg, format: nil, json_value: [])
+        format ||= @options[:format] if defined?(@options) && @options.is_a?(Hash)
+
+        if format == "json"
+          puts JSON.generate(json_value)
+        else
+          puts msg
+        end
+      end
+
+      # Standard check for database existence.
+      def require_database(repo)
+        return if Database.exists?(repo.git_dir)
+
+        error "Database not initialized. Run 'git pkgs init' first."
+      end
+    end
+  end
+end

data/lib/git/pkgs/pager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Git
+  module Pkgs
+    module Pager
+      # Returns the pager command following git's precedence:
+      # 1. GIT_PAGER environment variable
+      # 2. core.pager git config
+      # 3. PAGER environment variable
+      # 4. less as fallback
+      def git_pager
+        return ENV["GIT_PAGER"] if ENV["GIT_PAGER"] && !ENV["GIT_PAGER"].empty?
+
+        config_pager = `git config --get core.pager`.chomp
+        return config_pager unless config_pager.empty?
+
+        return ENV["PAGER"] if ENV["PAGER"] && !ENV["PAGER"].empty?
+
+        "less -FRSX"
+      end
+
+      # Returns true if paging is disabled (pager set to empty string or 'cat')
+      def pager_disabled?
+        pager = git_pager
+        pager.empty? || pager == "cat"
+      end
+
+      # Captures output from a block and sends it through the pager.
+      # Falls back to direct output if:
+      # - stdout is not a TTY
+      # - pager is disabled
+      # - pager command fails
+      def paginate
+        if !$stdout.tty? || pager_disabled? || paging_disabled?
+          yield
+          return
+        end
+
+        output = StringIO.new
+        old_stdout = $stdout
+        $stdout = output
+
+        begin
+          yield
+        ensure
+          $stdout = old_stdout
+        end
+
+        content = output.string
+        return if content.empty?
+
+        IO.popen(git_pager, "w") { |io| io.write(content) }
+      rescue Errno::EPIPE
+        # User quit pager early
+      rescue Errno::ENOENT
+        # Pager command not found, fall back to direct output
+        print content
+      end
+
+      # Check if paging was disabled via --no-pager option
+      def paging_disabled?
+        defined?(@options) && @options.is_a?(Hash) && @options[:no_pager]
+      end
+    end
+  end
+end