git-pkgs 0.2.0 → 0.4.0

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "bibliothecary"
+
+module Git
+  module Pkgs
+    module Commands
+      class DiffDriver
+        include Output
+
+        # Only lockfiles - manifests are human-readable and diff fine normally
+        LOCKFILE_PATTERNS = %w[
+          Brewfile.lock.json
+          Cargo.lock
+          Cartfile.resolved
+          Gemfile.lock
+          Gopkg.lock
+          Package.resolved
+          Pipfile.lock
+          Podfile.lock
+          Project.lock.json
+          bun.lock
+          composer.lock
+          gems.locked
+          glide.lock
+          go.sum
+          mix.lock
+          npm-shrinkwrap.json
+          package-lock.json
+          packages.lock.json
+          paket.lock
+          pnpm-lock.yaml
+          poetry.lock
+          project.assets.json
+          pubspec.lock
+          pylock.toml
+          shard.lock
+          uv.lock
+          yarn.lock
+        ].freeze
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          if @options[:install]
+            install_driver
+            return
+          end
+
+          if @options[:uninstall]
+            uninstall_driver
+            return
+          end
+
+          # textconv mode: single file argument, output dependency list
+          if @args.length == 1
+            output_textconv(@args[0])
+            return
+          end
+
+          error "Usage: git pkgs diff-driver <file>"
+        end
+
+        def output_textconv(file_path)
+          content = read_file(file_path)
+          deps = parse_deps(file_path, content)
+
+          # Output sorted dependency list for git to diff
+          deps.keys.sort.each do |name|
+            dep = deps[name]
+            # Only show type if it's not runtime (the default)
+            type_suffix = dep[:type] && dep[:type] != "runtime" ? " [#{dep[:type]}]" : ""
+            puts "#{name} #{dep[:requirement]}#{type_suffix}"
+          end
+        end
+
+        def install_driver
+          # Set up git config for textconv
+          system("git", "config", "diff.pkgs.textconv", "git-pkgs diff-driver")
+
+          # Add to .gitattributes
+          gitattributes_path = File.join(Dir.pwd, ".gitattributes")
+          existing = File.exist?(gitattributes_path) ? File.read(gitattributes_path) : ""
+
+          new_entries = []
+          LOCKFILE_PATTERNS.each do |pattern|
+            entry = "#{pattern} diff=pkgs"
+            new_entries << entry unless existing.include?(entry)
+          end
+
+          if new_entries.any?
+            File.open(gitattributes_path, "a") do |f|
+              f.puts unless existing.end_with?("\n") || existing.empty?
+              f.puts "# git-pkgs textconv for lockfiles"
+              new_entries.each { |entry| f.puts entry }
+            end
+          end
+
+          puts "Installed textconv driver for lockfiles."
+          puts "  git config: diff.pkgs.textconv = git-pkgs diff-driver"
+          puts "  .gitattributes: #{new_entries.count} lockfile patterns added"
+          puts
+          puts "Now 'git diff' on lockfiles shows dependency changes."
+          puts "Use 'git diff --no-textconv' to see raw diff."
+        end
+
+        def uninstall_driver
+          system("git", "config", "--unset", "diff.pkgs.textconv")
+
+          gitattributes_path = File.join(Dir.pwd, ".gitattributes")
+          if File.exist?(gitattributes_path)
+            lines = File.readlines(gitattributes_path)
+            lines.reject! { |line| line.include?("diff=pkgs") || line.include?("# git-pkgs") }
+            File.write(gitattributes_path, lines.join)
+          end
+
+          puts "Uninstalled diff driver."
+        end
+
+        def read_file(path)
+          return "" if path == "/dev/null"
+          return "" unless File.exist?(path)
+
+          File.read(path)
+        end
+
+        def parse_deps(path, content)
+          return {} if content.empty?
+
+          result = Bibliothecary.analyse_file(path, content).first
+          return {} unless result
+
+          result[:dependencies].map { |d| [d[:name], d] }.to_h
+        rescue StandardError
+          {}
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs diff-driver <file>"
+            opts.separator ""
+            opts.separator "Outputs dependency list for git textconv diffing."
+
+            opts.on("--install", "Install textconv driver for lockfiles") do
+              options[:install] = true
+            end
+
+            opts.on("--uninstall", "Uninstall textconv driver") do
+              options[:uninstall] = true
+            end
+
+            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/history.rb

@@ -6,6 +6,8 @@ module Git
   module Pkgs
     module Commands
       class History
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -15,11 +17,7 @@ module Git
           package_name = @args.shift
 
           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)
 
@@ -52,18 +50,15 @@ module Git
           end
 
           if changes.empty?
-            if package_name
-              puts "No history found for '#{package_name}'"
-            else
-              puts "No dependency changes found"
-            end
+            msg = package_name ? "No history found for '#{package_name}'" : "No dependency changes found"
+            empty_result msg
             return
           end
 
           if @options[:format] == "json"
             output_json(changes)
           else
-            output_text(changes, package_name)
+            paginate { output_text(changes, package_name) }
           end
         end
 
@@ -81,13 +76,13 @@ module Git
 
             case change.change_type
             when "added"
-              action = "Added"
+              action = Color.green("Added")
               version_info = change.requirement
             when "modified"
-              action = "Updated"
+              action = Color.yellow("Updated")
               version_info = "#{change.previous_requirement} -> #{change.requirement}"
             when "removed"
-              action = "Removed"
+              action = Color.red("Removed")
               version_info = change.requirement
             end
 
@@ -150,6 +145,10 @@ module Git
               options[:until] = 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
@@ -163,8 +162,7 @@ module Git
         def parse_time(str)
           Time.parse(str)
         rescue ArgumentError
-          $stderr.puts "Invalid date format: #{str}"
-          exit 1
+          error "Invalid date format: #{str}"
         end
       end
     end

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Hooks
+        include Output
+
         HOOK_SCRIPT = <<~SCRIPT
           #!/bin/sh
           # git-pkgs auto-update hook

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Info
+        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)
 
           db_path = Database.path(repo.git_dir)
           Database.connect(repo.git_dir)
@@ -71,7 +69,11 @@ module Git
           puts "  Commits with snapshots: #{snapshot_commits}"
           if total_dep_commits > 0
             ratio = (snapshot_commits.to_f / total_dep_commits * 100).round(1)
-            puts "  Coverage: #{ratio}% (1 snapshot per ~#{(total_dep_commits.to_f / snapshot_commits).round(0)} changes)"
+            if snapshot_commits > 0
+              puts "  Coverage: #{ratio}% (1 snapshot per ~#{(total_dep_commits / snapshot_commits)} changes)"
+            else
+              puts "  Coverage: #{ratio}%"
+            end
           end
         end
 

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Init
+        include Output
+
         BATCH_SIZE = 100
         SNAPSHOT_INTERVAL = 20 # Store snapshot every N dependency-changing commits
 
@@ -15,22 +17,19 @@ module Git
         def run
           repo = Repository.new
 
+          branch_name = @options[:branch] || repo.default_branch
+          error "Branch '#{branch_name}' not found" unless repo.branch_exists?(branch_name)
+
           if Database.exists?(repo.git_dir) && !@options[:force]
             puts "Database already exists. Use --force to rebuild."
             return
           end
 
           Database.drop if @options[:force]
-          Database.connect(repo.git_dir)
+          Database.connect(repo.git_dir, check_version: false)
           Database.create_schema(with_indexes: false)
           Database.optimize_for_bulk_writes
 
-          branch_name = @options[:branch] || repo.default_branch
-          unless repo.branch_exists?(branch_name)
-            $stderr.puts "Branch '#{branch_name}' not found"
-            exit 1
-          end
-
           branch = Models::Branch.find_or_create(branch_name)
           analyzer = Analyzer.new(repo)
 
@@ -74,6 +73,7 @@ module Git
           dependency_commit_count = 0
           snapshots_stored = 0
           processed = 0
+          last_processed_sha = nil
 
           flush = lambda do
             return if pending_commits.empty?
@@ -161,6 +161,8 @@ module Git
               position: processed
             }
 
+            last_processed_sha = rugged_commit.oid
+
             if has_changes
               dependency_commit_count += 1
 
@@ -207,13 +209,12 @@ module Git
             flush.call if pending_commits.size >= BATCH_SIZE
           end
 
-          # Always store final snapshot for HEAD
-          if snapshot.any?
-            last_sha = commits.last&.oid
-            if last_sha && !pending_snapshots.any? { |s| s[:sha] == last_sha }
+          # Always store final snapshot for the last processed commit
+          if snapshot.any? && last_processed_sha
+            unless pending_snapshots.any? { |s| s[:sha] == last_processed_sha }
               snapshot.each do |(manifest_path, name), dep_info|
                 pending_snapshots << {
-                  sha: last_sha,
+                  sha: last_processed_sha,
                   manifest_path: manifest_path,
                   name: name,
                   ecosystem: dep_info[:ecosystem],

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class List
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -11,26 +13,19 @@ 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)
 
           commit_sha = @options[:commit] || repo.head_sha
           target_commit = Models::Commit.find_by(sha: commit_sha)
 
-          unless target_commit
-            $stderr.puts "Commit #{commit_sha[0, 7]} not found in database"
-            exit 1
-          end
+          error "Commit #{commit_sha[0, 7]} not found in database" unless target_commit
 
           deps = compute_dependencies_at_commit(target_commit, repo)
 
           if deps.empty?
-            puts "No dependencies found"
+            empty_result "No dependencies found"
             return
           end
 
@@ -47,16 +42,20 @@ module Git
             require "json"
             puts JSON.pretty_generate(deps)
           else
-            grouped = deps.group_by { |d| [d[:manifest_path], d[:ecosystem]] }
+            paginate { output_text(deps) }
+          end
+        end
 
-            grouped.each do |(path, platform), manifest_deps|
-              puts "#{path} (#{platform}):"
-              manifest_deps.sort_by { |d| d[:name] }.each do |dep|
-                type_suffix = dep[:dependency_type] ? " [#{dep[:dependency_type]}]" : ""
-                puts "  #{dep[:name]} #{dep[:requirement]}#{type_suffix}"
-              end
-              puts
+        def output_text(deps)
+          grouped = deps.group_by { |d| [d[:manifest_path], d[:ecosystem]] }
+
+          grouped.each do |(path, platform), manifest_deps|
+            puts "#{path} (#{platform}):"
+            manifest_deps.sort_by { |d| d[:name] }.each do |dep|
+              type_suffix = dep[:dependency_type] ? " [#{dep[:dependency_type]}]" : ""
+              puts "  #{dep[:name]} #{dep[:requirement]}#{type_suffix}"
             end
+            puts
           end
         end
 
@@ -144,6 +143,10 @@ module Git
               options[:format] = 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/log.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Git
+  module Pkgs
+    module Commands
+      class Log
+        include Output
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+          require_database(repo)
+
+          Database.connect(repo.git_dir)
+
+          commits = Models::Commit
+            .where(has_dependency_changes: true)
+            .order(committed_at: :desc)
+
+          commits = commits.where("author_name LIKE ? OR author_email LIKE ?",
+            "%#{@options[:author]}%", "%#{@options[:author]}%") if @options[:author]
+          commits = commits.where("committed_at >= ?", parse_time(@options[:since])) if @options[:since]
+          commits = commits.where("committed_at <= ?", parse_time(@options[:until])) if @options[:until]
+
+          commits = commits.limit(@options[:limit] || 20)
+
+          if commits.empty?
+            empty_result "No commits with dependency changes found"
+            return
+          end
+
+          if @options[:format] == "json"
+            output_json(commits)
+          else
+            paginate { output_text(commits) }
+          end
+        end
+
+        def output_text(commits)
+          commits.each do |commit|
+            changes = commit.dependency_changes
+            changes = changes.where(ecosystem: @options[:ecosystem]) if @options[:ecosystem]
+            next if changes.empty?
+
+            puts "#{commit.short_sha} #{commit.message&.lines&.first&.strip}"
+            puts "Author: #{commit.author_name} <#{commit.author_email}>"
+            puts "Date:   #{commit.committed_at.strftime("%Y-%m-%d")}"
+            puts
+
+            added = changes.select { |c| c.change_type == "added" }
+            modified = changes.select { |c| c.change_type == "modified" }
+            removed = changes.select { |c| c.change_type == "removed" }
+
+            added.each do |change|
+              puts "  + #{change.name} #{change.requirement}"
+            end
+
+            modified.each do |change|
+              puts "  ~ #{change.name} #{change.previous_requirement} -> #{change.requirement}"
+            end
+
+            removed.each do |change|
+              puts "  - #{change.name}"
+            end
+
+            puts
+          end
+        end
+
+        def output_json(commits)
+          require "json"
+
+          data = commits.map do |commit|
+            changes = commit.dependency_changes
+            changes = changes.where(ecosystem: @options[:ecosystem]) if @options[:ecosystem]
+
+            {
+              sha: commit.sha,
+              short_sha: commit.short_sha,
+              message: commit.message&.lines&.first&.strip,
+              author_name: commit.author_name,
+              author_email: commit.author_email,
+              date: commit.committed_at.iso8601,
+              changes: changes.map do |change|
+                {
+                  name: change.name,
+                  change_type: change.change_type,
+                  requirement: change.requirement,
+                  previous_requirement: change.previous_requirement,
+                  ecosystem: change.ecosystem
+                }
+              end
+            }
+          end
+
+          puts JSON.pretty_generate(data)
+        end
+
+        def parse_time(str)
+          Time.parse(str)
+        rescue ArgumentError
+          error "Invalid date format: #{str}"
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs log [options]"
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("--author=NAME", "Filter by author name or email") do |v|
+              options[:author] = v
+            end
+
+            opts.on("--since=DATE", "Show commits after date") do |v|
+              options[:since] = v
+            end
+
+            opts.on("--until=DATE", "Show commits before date") do |v|
+              options[:until] = v
+            end
+
+            opts.on("-n", "--limit=N", Integer, "Limit commits (default: 20)") do |v|
+              options[:limit] = v
+            end
+
+            opts.on("-f", "--format=FORMAT", "Output format (text, json)") do |v|
+              options[:format] = 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
+            end
+          end
+
+          parser.parse!(@args)
+          options
+        end
+      end
+    end
+  end
+end