git-pkgs 0.4.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

@@ -42,6 +42,7 @@ module Git
         def initialize(args)
           @args = args
           @options = parse_options
+          Config.configure_bibliothecary
         end
 
         def run
@@ -99,12 +100,12 @@ module Git
             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."
+          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
@@ -117,7 +118,7 @@ module Git
             File.write(gitattributes_path, lines.join)
           end
 
-          puts "Uninstalled diff driver."
+          info "Uninstalled diff driver."
         end
 
         def read_file(path)
@@ -132,6 +133,7 @@ module Git
 
           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

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)
 
@@ -77,6 +82,61 @@ module Git
           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
@@ -94,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

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

@@ -6,8 +6,16 @@ module Git
       class Init
         include Output
 
-        BATCH_SIZE = 100
-        SNAPSHOT_INTERVAL = 20 # Store snapshot every N dependency-changing commits
+        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
@@ -18,10 +26,10 @@ module Git
           repo = Repository.new
 
           branch_name = @options[:branch] || repo.default_branch
-          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)
 
           if Database.exists?(repo.git_dir) && !@options[:force]
-            puts "Database already exists. Use --force to rebuild."
+            info "Database already exists. Use --force to rebuild."
             return
           end
 
@@ -33,29 +41,33 @@ module Git
           branch = Models::Branch.find_or_create(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, @options[:since])
           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)
 
           branch.update(last_analyzed_sha: repo.branch_target(branch_name))
 
-          print "\rCreating indexes..."
+          print "\rCreating indexes...#{' ' * 20}" unless Git::Pkgs.quiet
           Database.create_bulk_indexes
           Database.optimize_for_reads
 
           cache_stats = analyzer.cache_stats
 
-          puts "\rDone!#{' ' * 20}"
-          puts "Analyzed #{total} commits"
-          puts "Found #{stats[:dependency_commits]} commits with dependency changes"
-          puts "Stored #{stats[:snapshots_stored]} snapshots (every #{SNAPSHOT_INTERVAL} changes)"
-          puts "Blob cache: #{cache_stats[:cached_blobs]} unique blobs, #{cache_stats[:blobs_with_hits]} had cache hits"
+          info "\rDone!#{' ' * 20}"
+          info "Analyzed #{total} commits"
+          info "Found #{stats[:dependency_commits]} commits with dependency changes"
+          info "Stored #{stats[:snapshots_stored]} snapshots (every #{snapshot_interval} changes)"
+          info "Blob cache: #{cache_stats[:cached_blobs]} unique blobs, #{cache_stats[:blobs_with_hits]} had cache hits"
 
-          if @options[:hooks]
+          unless @options[:no_hooks]
             Commands::Hooks.new(["--install"]).run
           end
         end
@@ -135,9 +147,11 @@ module Git
             pending_snapshots.clear
           end
 
+          progress_interval = [total / 100, 10].max
+
           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 % progress_interval == 0 || processed == total)
 
             next if rugged_commit.parents.length > 1 # skip merge commits
 
@@ -191,7 +205,7 @@ module Git
               snapshot = result[:snapshot]
 
               # Store snapshot at intervals
-              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,
@@ -206,7 +220,7 @@ module Git
               end
             end
 
-            flush.call if pending_commits.size >= BATCH_SIZE
+            flush.call if pending_commits.size >= batch_size
           end
 
           # Always store final snapshot for the last processed commit
@@ -249,8 +263,8 @@ module Git
               options[:force] = true
             end
 
-            opts.on("--hooks", "Install git hooks for auto-updating") do
-              options[:hooks] = true
+            opts.on("--no-hooks", "Skip installing git hooks") do
+              options[:no_hooks] = true
             end
 
             opts.on("-h", "--help", "Show this help") do

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

@@ -20,7 +20,7 @@ module Git
           commit_sha = @options[:commit] || repo.head_sha
           target_commit = Models::Commit.find_by(sha: commit_sha)
 
-          error "Commit #{commit_sha[0, 7]} not found in database" unless target_commit
+          error "Commit #{commit_sha[0, 7]} not in database. Run 'git pkgs update' to index new commits." unless target_commit
 
           deps = compute_dependencies_at_commit(target_commit, repo)
 
@@ -90,7 +90,7 @@ module Git
           # Replay changes from snapshot to target
           if snapshot_commit && snapshot_commit.id != target_commit.id
             changes = Models::DependencyChange
-              .joins(:commit, :manifest)
+              .joins(:commit)
               .where(commits: { id: branch.commit_ids })
               .where("commits.committed_at > ? AND commits.committed_at <= ?",
                      snapshot_commit.committed_at, target_commit.committed_at)