git-pkgs 0.1.0

data/lib/git/pkgs/cli.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Git
+  module Pkgs
+    class CLI
+      COMMANDS = %w[init update hooks info list tree history search why blame outdated stats diff branch].freeze
+
+      def self.run(args)
+        new(args).run
+      end
+
+      def initialize(args)
+        @args = args.dup
+        @options = {}
+      end
+
+      def run
+        command = @args.shift
+
+        case command
+        when nil, "-h", "--help", "help"
+          print_help
+        when "-v", "--version", "version"
+          puts "git-pkgs #{Git::Pkgs::VERSION}"
+        when *COMMANDS
+          run_command(command)
+        else
+          $stderr.puts "Unknown command: #{command}"
+          $stderr.puts "Run 'git pkgs help' for usage"
+          exit 1
+        end
+      end
+
+      def run_command(command)
+        command_class = Commands.const_get(command.capitalize.gsub(/_([a-z])/) { $1.upcase })
+        command_class.new(@args).run
+      rescue NameError
+        $stderr.puts "Command '#{command}' not yet implemented"
+        exit 1
+      end
+
+      def print_help
+        puts <<~HELP
+          Usage: git pkgs <command> [options]
+
+          Commands:
+            init      Initialize the package database for this repository
+            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
+            why       Explain why a dependency exists
+            blame     Show who added each dependency
+            outdated  Show dependencies that haven't been updated
+            stats     Show dependency statistics
+            diff      Show dependency changes between commits
+
+          Options:
+            -h, --help     Show this help message
+            -v, --version  Show version
+
+          Run 'git pkgs <command> --help' for command-specific options.
+        HELP
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Blame
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+
+          unless Database.exists?(repo.git_dir)
+            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
+            exit 1
+          end
+
+          Database.connect(repo.git_dir)
+
+          # Get current dependencies at the last analyzed commit
+          branch_name = @options[:branch] || repo.default_branch
+          branch = Models::Branch.find_by(name: branch_name)
+
+          unless branch&.last_analyzed_sha
+            $stderr.puts "No analysis found for branch '#{branch_name}'"
+            exit 1
+          end
+
+          current_commit = Models::Commit.find_by(sha: branch.last_analyzed_sha)
+          snapshots = current_commit&.dependency_snapshots&.includes(:manifest) || []
+
+          if @options[:ecosystem]
+            snapshots = snapshots.where(ecosystem: @options[:ecosystem])
+          end
+
+          if snapshots.empty?
+            puts "No dependencies found"
+            return
+          end
+
+          # For each current dependency, find who added it
+          blame_data = []
+
+          snapshots.each do |snapshot|
+            added_change = Models::DependencyChange
+              .includes(:commit)
+              .where(name: snapshot.name, manifest: snapshot.manifest)
+              .added
+              .order("commits.committed_at ASC")
+              .first
+
+            next unless added_change
+
+            commit = added_change.commit
+            author = best_author(commit)
+
+            blame_data << {
+              name: snapshot.name,
+              ecosystem: snapshot.ecosystem,
+              requirement: snapshot.requirement,
+              manifest: snapshot.manifest.path,
+              author: author,
+              date: commit.committed_at,
+              sha: commit.short_sha
+            }
+          end
+
+          if @options[:format] == "json"
+            require "json"
+            json_data = blame_data.map do |d|
+              d.merge(date: d[:date].iso8601)
+            end
+            puts JSON.pretty_generate(json_data)
+          else
+            grouped = blame_data.group_by { |d| [d[:manifest], d[:ecosystem]] }
+
+            grouped.each do |(manifest, ecosystem), deps|
+              puts "#{manifest} (#{ecosystem}):"
+
+              max_name_len = deps.map { |d| d[:name].length }.max
+              max_author_len = deps.map { |d| d[:author].length }.max
+
+              deps.sort_by { |d| d[:name] }.each do |dep|
+                date = dep[:date].strftime("%Y-%m-%d")
+                puts "  #{dep[:name].ljust(max_name_len)}  #{dep[:author].ljust(max_author_len)}  #{date}  #{dep[:sha]}"
+              end
+              puts
+            end
+          end
+        end
+
+        def best_author(commit)
+          authors = [commit.author_name] + parse_coauthors(commit.message)
+
+          # Prefer human authors over bots
+          human = authors.find { |a| !bot_author?(a) }
+          human || authors.first
+        end
+
+        def parse_coauthors(message)
+          return [] unless message
+
+          message.scan(/^Co-authored-by:\s*(.+?)\s*<[^>]+>/i).flatten
+        end
+
+        def bot_author?(name)
+          name =~ /\[bot\]$|^dependabot|^renovate|^github-actions/i
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs blame [options]"
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-b", "--branch=NAME", "Branch to analyze") do |v|
+              options[:branch] = v
+            end
+
+            opts.on("-f", "--format=FORMAT", "Output format (text, json)") do |v|
+              options[:format] = v
+            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/branch.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Branch
+        BATCH_SIZE = 100
+        SNAPSHOT_INTERVAL = 20
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          subcommand = @args.shift
+
+          case subcommand
+          when "add"
+            add_branch
+          when "list"
+            list_branches
+          when "remove", "rm"
+            remove_branch
+          when nil, "-h", "--help"
+            print_help
+          else
+            $stderr.puts "Unknown subcommand: #{subcommand}"
+            $stderr.puts "Run 'git pkgs branch --help' for usage"
+            exit 1
+          end
+        end
+
+        def add_branch
+          branch_name = @args.shift
+          unless branch_name
+            $stderr.puts "Usage: git pkgs branch add <name>"
+            exit 1
+          end
+
+          repo = Repository.new
+
+          unless Database.exists?(repo.git_dir)
+            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
+            exit 1
+          end
+
+          Database.connect(repo.git_dir)
+
+          unless repo.branch_exists?(branch_name)
+            $stderr.puts "Branch '#{branch_name}' not found"
+            exit 1
+          end
+
+          existing = Models::Branch.find_by(name: branch_name)
+          if existing
+            puts "Branch '#{branch_name}' already tracked (#{existing.commits.count} commits)"
+            puts "Use 'git pkgs update' to refresh"
+            return
+          end
+
+          Database.optimize_for_bulk_writes
+
+          branch = Models::Branch.create!(name: branch_name)
+          analyzer = Analyzer.new(repo)
+
+          puts "Analyzing branch: #{branch_name}"
+
+          walker = repo.walk(branch_name)
+          commits = walker.to_a
+          total = commits.size
+
+          stats = bulk_process_commits(commits, branch, analyzer, total, repo)
+
+          branch.update(last_analyzed_sha: repo.branch_target(branch_name))
+
+          Database.optimize_for_reads
+
+          puts "\rDone!#{' ' * 20}"
+          puts "Analyzed #{total} commits"
+          puts "Found #{stats[:dependency_commits]} commits with dependency changes"
+          puts "Stored #{stats[:snapshots_stored]} snapshots"
+        end
+
+        def list_branches
+          repo = Repository.new
+
+          unless Database.exists?(repo.git_dir)
+            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
+            exit 1
+          end
+
+          Database.connect(repo.git_dir)
+
+          branches = Models::Branch.all
+
+          if branches.empty?
+            puts "No branches tracked"
+            return
+          end
+
+          puts "Tracked branches:"
+          branches.each do |branch|
+            commit_count = branch.commits.count
+            dep_commits = branch.commits.where(has_dependency_changes: true).count
+            last_sha = branch.last_analyzed_sha&.slice(0, 7) || "none"
+            puts "  #{branch.name}: #{commit_count} commits (#{dep_commits} with deps), last: #{last_sha}"
+          end
+        end
+
+        def remove_branch
+          branch_name = @args.shift
+          unless branch_name
+            $stderr.puts "Usage: git pkgs branch remove <name>"
+            exit 1
+          end
+
+          repo = Repository.new
+
+          unless Database.exists?(repo.git_dir)
+            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
+            exit 1
+          end
+
+          Database.connect(repo.git_dir)
+
+          branch = Models::Branch.find_by(name: branch_name)
+          unless branch
+            $stderr.puts "Branch '#{branch_name}' not tracked"
+            exit 1
+          end
+
+          # Only delete branch_commits, keep shared commits
+          count = branch.branch_commits.count
+          branch.branch_commits.delete_all
+          branch.destroy
+
+          puts "Removed branch '#{branch_name}' (#{count} branch-commit links)"
+        end
+
+        def bulk_process_commits(commits, branch, analyzer, total, repo)
+          now = Time.now
+          snapshot = {}
+          manifests_cache = {}
+
+          pending_commits = []
+          pending_branch_commits = []
+          pending_changes = []
+          pending_snapshots = []
+
+          dependency_commit_count = 0
+          snapshots_stored = 0
+          processed = 0
+
+          flush = lambda do
+            return if pending_commits.empty?
+
+            ActiveRecord::Base.transaction do
+              # Use upsert for commits since they may already exist from other branches
+              if pending_commits.any?
+                Models::Commit.upsert_all(
+                  pending_commits,
+                  unique_by: :sha
+                )
+              end
+
+              commit_ids = Models::Commit
+                .where(sha: pending_commits.map { |c| c[:sha] })
+                .pluck(:sha, :id).to_h
+
+              if pending_branch_commits.any?
+                branch_commit_records = pending_branch_commits.map do |bc|
+                  { branch_id: bc[:branch_id], commit_id: commit_ids[bc[:sha]], position: bc[:position] }
+                end
+                Models::BranchCommit.insert_all(branch_commit_records)
+              end
+
+              if pending_changes.any?
+                manifest_ids = Models::Manifest.pluck(:path, :id).to_h
+                change_records = pending_changes.map do |c|
+                  {
+                    commit_id: commit_ids[c[:sha]],
+                    manifest_id: manifest_ids[c[:manifest_path]],
+                    name: c[:name],
+                    ecosystem: c[:ecosystem],
+                    change_type: c[:change_type],
+                    requirement: c[:requirement],
+                    previous_requirement: c[:previous_requirement],
+                    dependency_type: c[:dependency_type],
+                    created_at: now,
+                    updated_at: now
+                  }
+                end
+                Models::DependencyChange.insert_all(change_records)
+              end
+
+              if pending_snapshots.any?
+                manifest_ids ||= Models::Manifest.pluck(:path, :id).to_h
+                snapshot_records = pending_snapshots.map do |s|
+                  {
+                    commit_id: commit_ids[s[:sha]],
+                    manifest_id: manifest_ids[s[:manifest_path]],
+                    name: s[:name],
+                    ecosystem: s[:ecosystem],
+                    requirement: s[:requirement],
+                    dependency_type: s[:dependency_type],
+                    created_at: now,
+                    updated_at: now
+                  }
+                end
+                Models::DependencySnapshot.insert_all(snapshot_records)
+              end
+            end
+
+            pending_commits.clear
+            pending_branch_commits.clear
+            pending_changes.clear
+            pending_snapshots.clear
+          end
+
+          commits.each do |rugged_commit|
+            processed += 1
+            print "\rProcessing commit #{processed}/#{total}..." if processed % 50 == 0 || processed == total
+
+            next if rugged_commit.parents.length > 1
+
+            result = analyzer.analyze_commit(rugged_commit, snapshot)
+            has_changes = result && result[:changes].any?
+
+            pending_commits << {
+              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: has_changes,
+              created_at: now,
+              updated_at: now
+            }
+
+            pending_branch_commits << {
+              branch_id: branch.id,
+              sha: rugged_commit.oid,
+              position: processed
+            }
+
+            if has_changes
+              dependency_commit_count += 1
+
+              result[:changes].each do |change|
+                manifest_key = change[:manifest_path]
+                unless manifests_cache[manifest_key]
+                  manifests_cache[manifest_key] = Models::Manifest.find_or_create(
+                    path: change[:manifest_path],
+                    ecosystem: change[:ecosystem],
+                    kind: change[:kind]
+                  )
+                end
+
+                pending_changes << {
+                  sha: rugged_commit.oid,
+                  manifest_path: manifest_key,
+                  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]
+
+              if dependency_commit_count % SNAPSHOT_INTERVAL == 0
+                snapshot.each do |(manifest_path, name), dep_info|
+                  pending_snapshots << {
+                    sha: rugged_commit.oid,
+                    manifest_path: manifest_path,
+                    name: name,
+                    ecosystem: dep_info[:ecosystem],
+                    requirement: dep_info[:requirement],
+                    dependency_type: dep_info[:dependency_type]
+                  }
+                end
+                snapshots_stored += snapshot.size
+              end
+            end
+
+            flush.call if pending_commits.size >= BATCH_SIZE
+          end
+
+          if snapshot.any?
+            last_sha = commits.last&.oid
+            if last_sha && !pending_snapshots.any? { |s| s[:sha] == last_sha }
+              snapshot.each do |(manifest_path, name), dep_info|
+                pending_snapshots << {
+                  sha: last_sha,
+                  manifest_path: manifest_path,
+                  name: name,
+                  ecosystem: dep_info[:ecosystem],
+                  requirement: dep_info[:requirement],
+                  dependency_type: dep_info[:dependency_type]
+                }
+              end
+              snapshots_stored += snapshot.size
+            end
+          end
+
+          flush.call
+
+          { dependency_commits: dependency_commit_count, snapshots_stored: snapshots_stored }
+        end
+
+        def print_help
+          puts <<~HELP
+            Usage: git pkgs branch <subcommand> [options]
+
+            Subcommands:
+              add <name>      Analyze and track a branch
+              list            List tracked branches
+              remove <name>   Stop tracking a branch
+
+            Examples:
+              git pkgs branch add feature-x
+              git pkgs branch list
+              git pkgs branch remove feature-x
+          HELP
+        end
+
+        def parse_options
+          options = {}
+          options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Diff
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+
+          unless Database.exists?(repo.git_dir)
+            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
+            exit 1
+          end
+
+          Database.connect(repo.git_dir)
+
+          from_sha = @options[:from]
+          to_sha = @options[:to] || repo.head_sha
+
+          unless from_sha
+            $stderr.puts "Usage: git pkgs diff --from=SHA [--to=SHA]"
+            exit 1
+          end
+
+          from_commit = Models::Commit.find_by(sha: from_sha) ||
+                        Models::Commit.where("sha LIKE ?", "#{from_sha}%").first
+          to_commit = Models::Commit.find_by(sha: to_sha) ||
+                      Models::Commit.where("sha LIKE ?", "#{to_sha}%").first
+
+          unless from_commit
+            $stderr.puts "Commit '#{from_sha}' not found in database"
+            exit 1
+          end
+
+          unless to_commit
+            $stderr.puts "Commit '#{to_sha}' not found in database"
+            exit 1
+          end
+
+          # Get all changes between the two commits
+          changes = Models::DependencyChange
+            .includes(:commit, :manifest)
+            .joins(:commit)
+            .where("commits.committed_at > ? AND commits.committed_at <= ?",
+                   from_commit.committed_at, to_commit.committed_at)
+            .order("commits.committed_at ASC")
+
+          if @options[:ecosystem]
+            changes = changes.where(ecosystem: @options[:ecosystem])
+          end
+
+          if changes.empty?
+            puts "No dependency changes between #{from_commit.short_sha} and #{to_commit.short_sha}"
+            return
+          end
+
+          puts "Dependency changes from #{from_commit.short_sha} to #{to_commit.short_sha}:"
+          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" }
+
+          if added.any?
+            puts "Added:"
+            added.group_by(&:name).each do |name, pkg_changes|
+              latest = pkg_changes.last
+              puts "  + #{name} #{latest.requirement} (#{latest.manifest.path})"
+            end
+            puts
+          end
+
+          if modified.any?
+            puts "Modified:"
+            modified.group_by(&:name).each do |name, pkg_changes|
+              first = pkg_changes.first
+              latest = pkg_changes.last
+              puts "  ~ #{name} #{first.previous_requirement} -> #{latest.requirement}"
+            end
+            puts
+          end
+
+          if removed.any?
+            puts "Removed:"
+            removed.group_by(&:name).each do |name, pkg_changes|
+              latest = pkg_changes.last
+              puts "  - #{name} (was #{latest.requirement})"
+            end
+            puts
+          end
+
+          # Summary
+          puts "Summary: +#{added.map(&:name).uniq.count} -#{removed.map(&:name).uniq.count} ~#{modified.map(&:name).uniq.count}"
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs diff --from=SHA [--to=SHA] [options]"
+
+            opts.on("-f", "--from=SHA", "Start commit (required)") do |v|
+              options[:from] = v
+            end
+
+            opts.on("-t", "--to=SHA", "End commit (default: HEAD)") do |v|
+              options[:to] = v
+            end
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-h", "--help", "Show this help") do
+              puts opts
+              exit
+            end
+          end
+
+          parser.parse!(@args)
+          options
+        end
+      end
+    end
+  end
+end