git-pkgs 0.3.0 → 0.5.0

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Completions
+        COMMANDS = CLI::COMMANDS
+        SUBCOMMAND_OPTIONS = {
+          "hooks" => %w[--install --uninstall],
+          "branch" => %w[--add --remove --list],
+          "diff" => %w[--format],
+          "list" => %w[--format --type],
+          "tree" => %w[--format],
+          "history" => %w[--format --limit],
+          "search" => %w[--format --limit],
+          "blame" => %w[--format],
+          "stale" => %w[--days --format],
+          "stats" => %w[--format],
+          "log" => %w[--limit --format],
+          "show" => %w[--format],
+          "where" => %w[--format],
+          "why" => %w[--format]
+        }.freeze
+
+        BASH_SCRIPT = <<~'BASH'
+          _git_pkgs() {
+            local cur prev commands
+            COMPREPLY=()
+            cur="${COMP_WORDS[COMP_CWORD]}"
+            prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+            commands="init update hooks info list tree history search where why blame stale stats diff branch show log upgrade schema completions"
+
+            if [[ ${COMP_CWORD} -eq 2 && ${COMP_WORDS[1]} == "pkgs" ]]; then
+              COMPREPLY=( $(compgen -W "${commands}" -- ${cur}) )
+              return 0
+            fi
+
+            if [[ ${COMP_CWORD} -eq 1 ]]; then
+              COMPREPLY=( $(compgen -W "${commands}" -- ${cur}) )
+              return 0
+            fi
+
+            case "${prev}" in
+              hooks)
+                COMPREPLY=( $(compgen -W "--install --uninstall --help" -- ${cur}) )
+                ;;
+              branch)
+                COMPREPLY=( $(compgen -W "--add --remove --list --help" -- ${cur}) )
+                ;;
+              completions)
+                COMPREPLY=( $(compgen -W "bash zsh install --help" -- ${cur}) )
+                ;;
+              diff|list|tree|history|search|blame|stale|stats|log|show|where|why)
+                COMPREPLY=( $(compgen -W "--format --help" -- ${cur}) )
+                ;;
+            esac
+
+            return 0
+          }
+
+          # Support both 'git pkgs' and 'git-pkgs' invocations
+          complete -F _git_pkgs git-pkgs
+
+          # For 'git pkgs' subcommand completion
+          if declare -F _git >/dev/null 2>&1; then
+            _git_pkgs_git_wrapper() {
+              if [[ ${COMP_WORDS[1]} == "pkgs" ]]; then
+                _git_pkgs
+              fi
+            }
+          fi
+        BASH
+
+        ZSH_SCRIPT = <<~'ZSH'
+          #compdef git-pkgs
+
+          _git-pkgs() {
+            local -a commands
+            commands=(
+              'init:Initialize the package database'
+              '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'
+              'where:Show where a package appears in manifest files'
+              'why:Explain why a dependency exists'
+              'blame:Show who added each dependency'
+              'stale:Show dependencies that have not 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'
+              'completions:Generate shell completions'
+            )
+
+            _arguments -C \
+              '1: :->command' \
+              '*:: :->args'
+
+            case $state in
+              command)
+                _describe -t commands 'git-pkgs commands' commands
+                ;;
+              args)
+                case $words[1] in
+                  hooks)
+                    _arguments \
+                      '--install[Install git hooks]' \
+                      '--uninstall[Remove git hooks]' \
+                      '--help[Show help]'
+                    ;;
+                  branch)
+                    _arguments \
+                      '--add[Add a branch to track]' \
+                      '--remove[Remove a tracked branch]' \
+                      '--list[List tracked branches]' \
+                      '--help[Show help]'
+                    ;;
+                  completions)
+                    _arguments '1:shell:(bash zsh install)'
+                    ;;
+                  diff|list|tree|history|search|blame|stale|stats|log|show|where|why)
+                    _arguments \
+                      '--format[Output format]:format:(table json csv)' \
+                      '--help[Show help]'
+                    ;;
+                esac
+                ;;
+            esac
+          }
+
+          _git-pkgs "$@"
+        ZSH
+
+        def initialize(args)
+          @args = args
+        end
+
+        def run
+          shell = @args.first
+
+          case shell
+          when "bash"
+            puts BASH_SCRIPT
+          when "zsh"
+            puts ZSH_SCRIPT
+          when "install"
+            install_completions
+          when "-h", "--help", nil
+            print_help
+          else
+            $stderr.puts "Unknown shell: #{shell}"
+            $stderr.puts "Supported: bash, zsh, install"
+            exit 1
+          end
+        end
+
+        def install_completions
+          shell = detect_shell
+
+          case shell
+          when "zsh"
+            install_zsh_completions
+          when "bash"
+            install_bash_completions
+          else
+            $stderr.puts "Could not detect shell. Please run one of:"
+            $stderr.puts "  eval \"$(git pkgs completions bash)\""
+            $stderr.puts "  eval \"$(git pkgs completions zsh)\""
+            exit 1
+          end
+        end
+
+        def detect_shell
+          shell_env = ENV["SHELL"] || ""
+          if shell_env.include?("zsh")
+            "zsh"
+          elsif shell_env.include?("bash")
+            "bash"
+          end
+        end
+
+        def install_bash_completions
+          dir = File.expand_path("~/.local/share/bash-completion/completions")
+          FileUtils.mkdir_p(dir)
+          path = File.join(dir, "git-pkgs")
+          File.write(path, BASH_SCRIPT)
+          puts "Installed bash completions to #{path}"
+          puts "Restart your shell or run: source #{path}"
+        end
+
+        def install_zsh_completions
+          dir = File.expand_path("~/.zsh/completions")
+          FileUtils.mkdir_p(dir)
+          path = File.join(dir, "_git-pkgs")
+          File.write(path, ZSH_SCRIPT)
+          puts "Installed zsh completions to #{path}"
+          puts ""
+          puts "Add to your ~/.zshrc if not already present:"
+          puts "  fpath=(~/.zsh/completions $fpath)"
+          puts "  autoload -Uz compinit && compinit"
+          puts ""
+          puts "Then restart your shell or run: source ~/.zshrc"
+        end
+
+        def print_help
+          puts <<~HELP
+            Usage: git pkgs completions <shell>
+
+            Generate shell completion scripts.
+
+            Shells:
+              bash      Output bash completion script
+              zsh       Output zsh completion script
+              install   Auto-install completions for your shell
+
+            Examples:
+              git pkgs completions bash > ~/.local/share/bash-completion/completions/git-pkgs
+              git pkgs completions zsh > ~/.zsh/completions/_git-pkgs
+              eval "$(git pkgs completions bash)"
+              git pkgs completions install
+          HELP
+        end
+      end
+    end
+  end
+end

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

@@ -17,23 +17,24 @@ module Git
 
           Database.connect(repo.git_dir)
 
-          from_ref = @options[:from]
-          to_ref = @options[:to] || "HEAD"
+          from_ref, to_ref = parse_range_argument
+          from_ref ||= @options[:from]
+          to_ref ||= @options[:to] || "HEAD"
 
-          error "Usage: git pkgs diff --from=REF [--to=REF]" unless from_ref
+          error "Usage: git pkgs diff <commit>..<commit> or git pkgs diff --from=REF [--to=REF]" unless from_ref
 
           # Resolve git refs (like HEAD~10) to SHAs
           from_sha = repo.rev_parse(from_ref)
           to_sha = repo.rev_parse(to_ref)
 
-          error "Could not resolve '#{from_ref}'" unless from_sha
-          error "Could not resolve '#{to_ref}'" unless to_sha
+          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
 
-          from_commit = find_or_create_commit(repo, from_sha)
-          to_commit = find_or_create_commit(repo, to_sha)
+          from_commit = Models::Commit.find_or_create_from_repo(repo, from_sha)
+          to_commit = Models::Commit.find_or_create_from_repo(repo, to_sha)
 
-          error "Commit '#{from_sha[0..7]}' not found" unless from_commit
-          error "Commit '#{to_sha[0..7]}' not found" unless to_commit
+          error "Commit '#{from_sha[0..7]}' not in database. Run 'git pkgs update' to index new commits." unless from_commit
+          error "Commit '#{to_sha[0..7]}' not in database. Run 'git pkgs update' to index new commits." unless to_commit
 
           # Get all changes between the two commits
           changes = Models::DependencyChange
@@ -98,34 +99,36 @@ module Git
           puts "Summary: #{added_count} #{removed_count} #{modified_count}"
         end
 
-        def find_or_create_commit(repo, sha)
-          commit = Models::Commit.find_by(sha: sha) ||
-                   Models::Commit.where("sha LIKE ?", "#{sha}%").first
-          return commit if commit
-
-          # Lazily insert commit if it exists in git but not in database
-          rugged_commit = repo.lookup(sha)
-          return nil unless rugged_commit
-
-          Models::Commit.create!(
-            sha: rugged_commit.oid,
-            message: rugged_commit.message,
-            author_name: rugged_commit.author[:name],
-            author_email: rugged_commit.author[:email],
-            committed_at: rugged_commit.time,
-            has_dependency_changes: false
-          )
-        rescue Rugged::OdbError
-          nil
+        def parse_range_argument
+          return [nil, nil] if @args.empty?
+
+          arg = @args.first
+          return [nil, nil] if arg.start_with?("-")
+
+          if arg.include?("..")
+            @args.shift
+            parts = arg.split("..", 2)
+            [parts[0], parts[1].empty? ? "HEAD" : parts[1]]
+          else
+            # Single ref means "from that ref to HEAD"
+            @args.shift
+            [arg, "HEAD"]
+          end
         end
 
         def parse_options
           options = {}
 
           parser = OptionParser.new do |opts|
-            opts.banner = "Usage: git pkgs diff --from=REF [--to=REF] [options]"
-
-            opts.on("-f", "--from=REF", "Start commit (required)") do |v|
+            opts.banner = "Usage: git pkgs diff [<from>..<to>] [options]"
+            opts.separator ""
+            opts.separator "Examples:"
+            opts.separator "  git pkgs diff main..feature"
+            opts.separator "  git pkgs diff HEAD~10"
+            opts.separator "  git pkgs diff --from=v1.0 --to=v2.0"
+            opts.separator ""
+
+            opts.on("-f", "--from=REF", "Start commit") do |v|
               options[:from] = v
             end
 

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

@@ -0,0 +1,171 @@
+# 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
+          Config.configure_bibliothecary
+        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
+
+          info "Installed textconv driver for lockfiles."
+          info "  git config: diff.pkgs.textconv = git-pkgs diff-driver"
+          info "  .gitattributes: #{new_entries.count} lockfile patterns added"
+          info ""
+          info "Now 'git diff' on lockfiles shows dependency changes."
+          info "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
+
+          info "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
+          return {} if Config.filter_ecosystem?(result[:platform])
+
+          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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "time"
-
 module Git
   module Pkgs
     module Commands
@@ -159,11 +157,6 @@ module Git
           options
         end
 
-        def parse_time(str)
-          Time.parse(str)
-        rescue ArgumentError
-          error "Invalid date format: #{str}"
-        end
       end
     end
   end

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

@@ -40,7 +40,7 @@ module Git
             if File.exist?(hook_path)
               content = File.read(hook_path)
               if content.include?("git-pkgs")
-                puts "Hook #{hook_name} already contains git-pkgs"
+                info "Hook #{hook_name} already contains git-pkgs"
                 next
               end
 
@@ -48,15 +48,15 @@ module Git
                 f.puts "\n# git-pkgs auto-update"
                 f.puts "git pkgs update 2>/dev/null || true"
               end
-              puts "Appended git-pkgs to existing #{hook_name} hook"
+              info "Appended git-pkgs to existing #{hook_name} hook"
             else
               File.write(hook_path, HOOK_SCRIPT)
               File.chmod(0o755, hook_path)
-              puts "Created #{hook_name} hook"
+              info "Created #{hook_name} hook"
             end
           end
 
-          puts "Hooks installed successfully"
+          info "Hooks installed successfully"
         end
 
         def uninstall_hooks(repo)
@@ -70,7 +70,7 @@ module Git
 
             if content.strip == HOOK_SCRIPT.strip
               File.delete(hook_path)
-              puts "Removed #{hook_name} hook"
+              info "Removed #{hook_name} hook"
             elsif content.include?("git-pkgs")
               new_content = content.lines.reject { |line|
                 line.include?("git-pkgs") || line.include?("git pkgs")
@@ -79,15 +79,15 @@ module Git
 
               if new_content.strip.empty? || new_content.strip == "#!/bin/sh"
                 File.delete(hook_path)
-                puts "Removed #{hook_name} hook"
+                info "Removed #{hook_name} hook"
               else
                 File.write(hook_path, new_content)
-                puts "Removed git-pkgs from #{hook_name} hook"
+                info "Removed git-pkgs from #{hook_name} hook"
               end
             end
           end
 
-          puts "Hooks uninstalled successfully"
+          info "Hooks uninstalled successfully"
         end
 
         def show_status(repo)

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

@@ -12,6 +12,11 @@ module Git
         end
 
         def run
+          if @options[:ecosystems]
+            output_ecosystems
+            return
+          end
+
           repo = Repository.new
           require_database(repo)
 
@@ -69,10 +74,69 @@ 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
 
+        def output_ecosystems
+          require "bibliothecary"
+
+          all_ecosystems = Bibliothecary::Parsers.constants.map do |c|
+            parser = Bibliothecary::Parsers.const_get(c)
+            parser.platform_name if parser.respond_to?(:platform_name)
+          end.compact.sort
+
+          configured = Config.ecosystems
+          filtering = configured.any?
+
+          puts "Available Ecosystems"
+          puts "=" * 40
+          puts
+
+          enabled_ecos = []
+          disabled_ecos = []
+
+          all_ecosystems.each do |eco|
+            if Config.filter_ecosystem?(eco)
+              remote = Config.remote_ecosystem?(eco)
+              disabled_ecos << { name: eco, remote: remote }
+            else
+              enabled_ecos << eco
+            end
+          end
+
+          puts "Enabled:"
+          if enabled_ecos.any?
+            enabled_ecos.each { |eco| puts "  #{Color.green(eco)}" }
+          else
+            puts "  (none)"
+          end
+
+          puts
+          puts "Disabled:"
+          if disabled_ecos.any?
+            disabled_ecos.each do |eco|
+              suffix = eco[:remote] ? " (remote)" : ""
+              puts "  #{eco[:name]}#{suffix}"
+            end
+          else
+            puts "  (none)"
+          end
+
+          puts
+          if filtering
+            puts "Filtering: only #{configured.join(', ')}"
+          else
+            puts "All local ecosystems enabled"
+          end
+          puts "Remote ecosystems require explicit opt-in"
+          puts "Configure with: git config --add pkgs.ecosystems <name>"
+        end
+
         def format_size(bytes)
           units = %w[B KB MB GB]
           unit_index = 0
@@ -90,7 +154,11 @@ module Git
           options = {}
 
           parser = OptionParser.new do |opts|
-            opts.banner = "Usage: git pkgs info"
+            opts.banner = "Usage: git pkgs info [options]"
+
+            opts.on("--ecosystems", "Show available ecosystems and filter status") do
+              options[:ecosystems] = true
+            end
 
             opts.on("-h", "--help", "Show this help") do
               puts opts