git-pkgs 0.1.0

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class History
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          package_name = @args.shift
+
+          unless package_name
+            $stderr.puts "Usage: git pkgs history <package>"
+            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)
+
+          changes = Models::DependencyChange
+            .includes(:commit, :manifest)
+            .for_package(package_name)
+            .order("commits.committed_at ASC")
+
+          if @options[:ecosystem]
+            changes = changes.for_platform(@options[:ecosystem])
+          end
+
+          if changes.empty?
+            puts "No history found for '#{package_name}'"
+            return
+          end
+
+          if @options[:format] == "json"
+            output_json(changes)
+          else
+            output_text(changes, package_name)
+          end
+        end
+
+        def output_text(changes, package_name)
+          puts "History for #{package_name}:"
+          puts
+
+          changes.each do |change|
+            commit = change.commit
+            date = commit.committed_at.strftime("%Y-%m-%d")
+
+            case change.change_type
+            when "added"
+              action = "Added"
+              version_info = change.requirement
+            when "modified"
+              action = "Updated"
+              version_info = "#{change.previous_requirement} -> #{change.requirement}"
+            when "removed"
+              action = "Removed"
+              version_info = change.requirement
+            end
+
+            puts "#{date} #{action} #{version_info}"
+            puts "  Commit: #{commit.short_sha} #{commit.message&.lines&.first&.strip}"
+            puts "  Author: #{commit.author_name} <#{commit.author_email}>"
+            puts "  Manifest: #{change.manifest.path}"
+            puts
+          end
+        end
+
+        def output_json(changes)
+          require "json"
+
+          data = changes.map do |change|
+            {
+              date: change.commit.committed_at.iso8601,
+              change_type: change.change_type,
+              requirement: change.requirement,
+              previous_requirement: change.previous_requirement,
+              manifest: change.manifest.path,
+              ecosystem: change.ecosystem,
+              commit: {
+                sha: change.commit.sha,
+                message: change.commit.message&.lines&.first&.strip,
+                author_name: change.commit.author_name,
+                author_email: change.commit.author_email
+              }
+            }
+          end
+
+          puts JSON.pretty_generate(data)
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs history <package> [options]"
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = 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/hooks.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Hooks
+        HOOK_SCRIPT = <<~SCRIPT
+          #!/bin/sh
+          # git-pkgs auto-update hook
+          git pkgs update 2>/dev/null || true
+        SCRIPT
+
+        HOOKS = %w[post-commit post-merge].freeze
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+
+          if @options[:install]
+            install_hooks(repo)
+          elsif @options[:uninstall]
+            uninstall_hooks(repo)
+          else
+            show_status(repo)
+          end
+        end
+
+        def install_hooks(repo)
+          hooks_dir = File.join(repo.git_dir, "hooks")
+
+          HOOKS.each do |hook_name|
+            hook_path = File.join(hooks_dir, hook_name)
+
+            if File.exist?(hook_path)
+              content = File.read(hook_path)
+              if content.include?("git-pkgs")
+                puts "Hook #{hook_name} already contains git-pkgs"
+                next
+              end
+
+              File.open(hook_path, "a") do |f|
+                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"
+            else
+              File.write(hook_path, HOOK_SCRIPT)
+              File.chmod(0o755, hook_path)
+              puts "Created #{hook_name} hook"
+            end
+          end
+
+          puts "Hooks installed successfully"
+        end
+
+        def uninstall_hooks(repo)
+          hooks_dir = File.join(repo.git_dir, "hooks")
+
+          HOOKS.each do |hook_name|
+            hook_path = File.join(hooks_dir, hook_name)
+            next unless File.exist?(hook_path)
+
+            content = File.read(hook_path)
+
+            if content.strip == HOOK_SCRIPT.strip
+              File.delete(hook_path)
+              puts "Removed #{hook_name} hook"
+            elsif content.include?("git-pkgs")
+              new_content = content.lines.reject { |line|
+                line.include?("git-pkgs") || line.include?("git pkgs")
+              }.join
+              new_content = new_content.gsub(/\n# git-pkgs auto-update\n/, "\n")
+
+              if new_content.strip.empty? || new_content.strip == "#!/bin/sh"
+                File.delete(hook_path)
+                puts "Removed #{hook_name} hook"
+              else
+                File.write(hook_path, new_content)
+                puts "Removed git-pkgs from #{hook_name} hook"
+              end
+            end
+          end
+
+          puts "Hooks uninstalled successfully"
+        end
+
+        def show_status(repo)
+          hooks_dir = File.join(repo.git_dir, "hooks")
+
+          puts "Hook status:"
+          HOOKS.each do |hook_name|
+            hook_path = File.join(hooks_dir, hook_name)
+            if File.exist?(hook_path) && File.read(hook_path).include?("git-pkgs")
+              puts "  #{hook_name}: installed"
+            else
+              puts "  #{hook_name}: not installed"
+            end
+          end
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs hooks [options]"
+
+            opts.on("-i", "--install", "Install git hooks for auto-updating") do
+              options[:install] = true
+            end
+
+            opts.on("-u", "--uninstall", "Remove git hooks") 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/info.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Info
+        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
+
+          db_path = Database.path(repo.git_dir)
+          Database.connect(repo.git_dir)
+
+          puts "Database Info"
+          puts "=" * 40
+          puts
+
+          # File info
+          db_size = File.size(db_path)
+          puts "Location: #{db_path}"
+          puts "Size: #{format_size(db_size)}"
+          puts
+
+          # Row counts
+          puts "Row Counts"
+          puts "-" * 40
+          counts = {
+            "Branches" => Models::Branch.count,
+            "Commits" => Models::Commit.count,
+            "Branch-Commits" => Models::BranchCommit.count,
+            "Manifests" => Models::Manifest.count,
+            "Dependency Changes" => Models::DependencyChange.count,
+            "Dependency Snapshots" => Models::DependencySnapshot.count
+          }
+
+          counts.each do |name, count|
+            puts "  #{name.ljust(22)} #{count.to_s.rjust(10)}"
+          end
+          puts "  #{'-' * 34}"
+          puts "  #{'Total'.ljust(22)} #{counts.values.sum.to_s.rjust(10)}"
+          puts
+
+          # Branch info
+          puts "Branches"
+          puts "-" * 40
+          Models::Branch.all.each do |branch|
+            commit_count = branch.commits.count
+            last_sha = branch.last_analyzed_sha&.slice(0, 7) || "none"
+            puts "  #{branch.name}: #{commit_count} commits (last: #{last_sha})"
+          end
+          puts
+
+          # Snapshot coverage
+          puts "Snapshot Coverage"
+          puts "-" * 40
+          total_dep_commits = Models::Commit.where(has_dependency_changes: true).count
+          snapshot_commits = Models::Commit
+            .joins(:dependency_snapshots)
+            .distinct
+            .count
+          puts "  Commits with dependency changes: #{total_dep_commits}"
+          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)"
+          end
+        end
+
+        def format_size(bytes)
+          units = %w[B KB MB GB]
+          unit_index = 0
+          size = bytes.to_f
+
+          while size >= 1024 && unit_index < units.length - 1
+            size /= 1024
+            unit_index += 1
+          end
+
+          "#{size.round(1)} #{units[unit_index]}"
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs info"
+
+            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/init.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Init
+        BATCH_SIZE = 100
+        SNAPSHOT_INTERVAL = 20 # Store snapshot every N dependency-changing commits
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+
+          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.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)
+
+          puts "Analyzing branch: #{branch_name}"
+
+          walker = repo.walk(branch_name, @options[:since])
+          commits = walker.to_a
+          total = commits.size
+
+          stats = bulk_process_commits(commits, branch, analyzer, total)
+
+          branch.update(last_analyzed_sha: repo.branch_target(branch_name))
+
+          print "\rCreating indexes..."
+          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"
+
+          if @options[:hooks]
+            Commands::Hooks.new(["--install"]).run
+          end
+        end
+
+        def bulk_process_commits(commits, branch, analyzer, total)
+          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
+              Models::Commit.insert_all(pending_commits) if pending_commits.any?
+
+              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 # skip merge commits
+
+            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]
+
+              # Store snapshot at intervals
+              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
+
+          # 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 }
+              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 parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs init [options]"
+
+            opts.on("-b", "--branch=NAME", "Branch to analyze (default: default branch)") do |v|
+              options[:branch] = v
+            end
+
+            opts.on("-s", "--since=SHA", "Start from specific commit") do |v|
+              options[:since] = v
+            end
+
+            opts.on("-f", "--force", "Rebuild database from scratch") do
+              options[:force] = true
+            end
+
+            opts.on("--hooks", "Install git hooks for auto-updating") do
+              options[:hooks] = true
+            end
+
+            opts.on("-h", "--help", "Show this help") do
+              puts opts
+              exit
+            end
+          end
+
+          parser.parse!(@args)
+          options
+        end
+      end
+    end
+  end
+end