git-pkgs 0.1.0

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Tree
+        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 the commit to analyze
+          commit_sha = @options[:commit] || repo.head_sha
+          commit = find_commit_with_snapshot(commit_sha, repo)
+
+          unless commit
+            $stderr.puts "No dependency data found for commit #{commit_sha[0, 7]}"
+            exit 1
+          end
+
+          # Get current snapshots
+          snapshots = commit.dependency_snapshots.includes(:manifest)
+
+          if @options[:ecosystem]
+            snapshots = snapshots.where(ecosystem: @options[:ecosystem])
+          end
+
+          if snapshots.empty?
+            puts "No dependencies found"
+            return
+          end
+
+          # Group by manifest and build tree
+          grouped = snapshots.group_by { |s| s.manifest }
+
+          grouped.each do |manifest, deps|
+            puts "#{manifest.path} (#{manifest.ecosystem})"
+            puts
+
+            # Separate by dependency type
+            by_type = deps.group_by { |d| d.dependency_type || "runtime" }
+
+            by_type.each do |type, type_deps|
+              puts "  [#{type}]"
+              type_deps.sort_by(&:name).each do |dep|
+                print_dependency(dep, 2)
+              end
+              puts
+            end
+          end
+
+          # Show summary
+          puts "Total: #{snapshots.count} dependencies across #{grouped.keys.count} manifest(s)"
+        end
+
+        def print_dependency(dep, indent)
+          prefix = "  " * indent
+          version = dep.requirement || "*"
+          puts "#{prefix}#{dep.name} #{version}"
+
+          # If this manifest has lockfile data, we could show transitive deps
+          # For now, we just show the direct dependencies
+          # Future enhancement: parse lockfiles to show full tree
+        end
+
+        def find_commit_with_snapshot(sha, repo)
+          commit = Models::Commit.find_by(sha: sha) ||
+                   Models::Commit.where("sha LIKE ?", "#{sha}%").first
+          return commit if commit&.dependency_snapshots&.any?
+
+          # Find most recent commit with a snapshot
+          branch_name = @options[:branch] || repo.default_branch
+          branch = Models::Branch.find_by(name: branch_name)
+          return nil unless branch
+
+          branch.commits
+            .joins(:dependency_snapshots)
+            .where("commits.committed_at <= ?", commit&.committed_at || Time.now)
+            .order(committed_at: :desc)
+            .distinct
+            .first
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs tree [options]"
+
+            opts.on("-c", "--commit=SHA", "Show dependencies at specific commit") do |v|
+              options[:commit] = v
+            end
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-b", "--branch=NAME", "Branch context for finding snapshots") do |v|
+              options[:branch] = 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/update.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Update
+        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)
+
+          branch_name = @options[:branch] || repo.default_branch
+          branch = Models::Branch.find_by(name: branch_name)
+
+          unless branch
+            $stderr.puts "Branch '#{branch_name}' not in database. Run 'git pkgs init --branch=#{branch_name}' first."
+            exit 1
+          end
+
+          since_sha = branch.last_analyzed_sha
+          current_sha = repo.branch_target(branch_name)
+
+          if since_sha == current_sha
+            puts "Already up to date."
+            return
+          end
+
+          analyzer = Analyzer.new(repo)
+
+          # Get current snapshot from last analyzed commit
+          last_commit = Models::Commit.find_by(sha: since_sha)
+          snapshot = {}
+
+          if last_commit
+            last_commit.dependency_snapshots.includes(:manifest).each do |s|
+              key = [s.manifest.path, s.name]
+              snapshot[key] = {
+                ecosystem: s.ecosystem,
+                requirement: s.requirement,
+                dependency_type: s.dependency_type
+              }
+            end
+          end
+
+          walker = repo.walk(branch_name, since_sha)
+          commits = walker.to_a
+          total = commits.size
+          processed = 0
+          dependency_commits = 0
+          last_position = Models::BranchCommit.where(branch: branch).maximum(:position) || 0
+
+          puts "Updating branch: #{branch_name}"
+          puts "Found #{total} new commits"
+
+          commits.each do |rugged_commit|
+            processed += 1
+            print "\rProcessing commit #{processed}/#{total}..."
+
+            result = analyzer.analyze_commit(rugged_commit, snapshot)
+
+            commit = Models::Commit.find_or_create_from_rugged(rugged_commit)
+            Models::BranchCommit.find_or_create_by(
+              branch: branch,
+              commit: commit,
+              position: last_position + processed
+            )
+
+            if result && result[:changes].any?
+              dependency_commits += 1
+              commit.update(has_dependency_changes: true)
+
+              result[:changes].each do |change|
+                manifest = Models::Manifest.find_or_create(
+                  path: change[:manifest_path],
+                  ecosystem: change[:ecosystem],
+                  kind: change[:kind]
+                )
+
+                Models::DependencyChange.create!(
+                  commit: commit,
+                  manifest: manifest,
+                  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]
+
+              snapshot.each do |(manifest_path, name), dep_info|
+                manifest = Models::Manifest.find_by(path: manifest_path)
+                Models::DependencySnapshot.find_or_create_by(
+                  commit: commit,
+                  manifest: manifest,
+                  name: name
+                ) do |s|
+                  s.ecosystem = dep_info[:ecosystem]
+                  s.requirement = dep_info[:requirement]
+                  s.dependency_type = dep_info[:dependency_type]
+                end
+              end
+            end
+          end
+
+          branch.update(last_analyzed_sha: current_sha)
+
+          puts "\nDone!"
+          puts "Processed #{total} new commits"
+          puts "Found #{dependency_commits} commits with dependency changes"
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs update [options]"
+
+            opts.on("-b", "--branch=NAME", "Branch to update (default: default branch)") do |v|
+              options[:branch] = 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/why.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Why
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          package_name = @args.shift
+
+          unless package_name
+            $stderr.puts "Usage: git pkgs why <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)
+
+          # Find the first time this package was added
+          added_change = Models::DependencyChange
+            .includes(:commit, :manifest)
+            .for_package(package_name)
+            .added
+            .order("commits.committed_at ASC")
+
+          if @options[:ecosystem]
+            added_change = added_change.for_platform(@options[:ecosystem])
+          end
+
+          added_change = added_change.first
+
+          unless added_change
+            puts "Package '#{package_name}' not found in dependency history"
+            return
+          end
+
+          commit = added_change.commit
+
+          puts "#{package_name} was added in commit #{commit.short_sha}"
+          puts
+          puts "Date:    #{commit.committed_at.strftime("%Y-%m-%d %H:%M")}"
+          puts "Author:  #{commit.author_name} <#{commit.author_email}>"
+          puts "Manifest: #{added_change.manifest.path}"
+          puts "Version: #{added_change.requirement}"
+          puts
+          puts "Commit message:"
+          puts commit.message.to_s.lines.map { |l| "  #{l}" }.join
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs why <package> [options]"
+
+            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

data/lib/git/pkgs/database.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "sqlite3"
+
+module Git
+  module Pkgs
+    class Database
+      DB_FILE = "pkgs.sqlite3"
+
+      def self.path(git_dir = nil)
+        git_dir ||= find_git_dir
+        File.join(git_dir, DB_FILE)
+      end
+
+      def self.find_git_dir
+        dir = Dir.pwd
+        loop do
+          git_dir = File.join(dir, ".git")
+          return git_dir if File.directory?(git_dir)
+
+          parent = File.dirname(dir)
+          raise NotInGitRepoError, "Not in a git repository" if parent == dir
+
+          dir = parent
+        end
+      end
+
+      def self.connect(git_dir = nil)
+        db_path = path(git_dir)
+        ActiveRecord::Base.establish_connection(
+          adapter: "sqlite3",
+          database: db_path
+        )
+      end
+
+      def self.connect_memory
+        ActiveRecord::Base.establish_connection(
+          adapter: "sqlite3",
+          database: ":memory:"
+        )
+        create_schema
+      end
+
+      def self.exists?(git_dir = nil)
+        File.exist?(path(git_dir))
+      end
+
+      def self.create_schema(with_indexes: true)
+        ActiveRecord::Schema.define do
+          create_table :branches, if_not_exists: true do |t|
+            t.string :name, null: false
+            t.string :last_analyzed_sha
+            t.timestamps
+          end
+          add_index :branches, :name, unique: true, if_not_exists: true
+
+          create_table :commits, if_not_exists: true do |t|
+            t.string :sha, null: false
+            t.text :message
+            t.string :author_name
+            t.string :author_email
+            t.datetime :committed_at
+            t.boolean :has_dependency_changes, default: false
+            t.timestamps
+          end
+          add_index :commits, :sha, unique: true, if_not_exists: true
+
+          create_table :branch_commits, if_not_exists: true do |t|
+            t.references :branch, foreign_key: true
+            t.references :commit, foreign_key: true
+            t.integer :position
+          end
+          add_index :branch_commits, [:branch_id, :commit_id], unique: true, if_not_exists: true
+
+          create_table :manifests, if_not_exists: true do |t|
+            t.string :path, null: false
+            t.string :ecosystem
+            t.string :kind
+            t.timestamps
+          end
+          add_index :manifests, :path, if_not_exists: true
+
+          create_table :dependency_changes, if_not_exists: true do |t|
+            t.references :commit, foreign_key: true
+            t.references :manifest, foreign_key: true
+            t.string :name, null: false
+            t.string :ecosystem
+            t.string :change_type, null: false
+            t.string :requirement
+            t.string :previous_requirement
+            t.string :dependency_type
+            t.timestamps
+          end
+
+          create_table :dependency_snapshots, if_not_exists: true do |t|
+            t.references :commit, foreign_key: true
+            t.references :manifest, foreign_key: true
+            t.string :name, null: false
+            t.string :ecosystem
+            t.string :requirement
+            t.string :dependency_type
+            t.timestamps
+          end
+        end
+
+        create_bulk_indexes if with_indexes
+      end
+
+      def self.create_bulk_indexes
+        conn = ActiveRecord::Base.connection
+
+        # dependency_changes indexes
+        conn.add_index :dependency_changes, :name, if_not_exists: true
+        conn.add_index :dependency_changes, :ecosystem, if_not_exists: true
+        conn.add_index :dependency_changes, [:commit_id, :name], if_not_exists: true
+
+        # dependency_snapshots indexes
+        conn.add_index :dependency_snapshots, [:commit_id, :manifest_id, :name],
+                       unique: true, name: "idx_snapshots_unique", if_not_exists: true
+        conn.add_index :dependency_snapshots, :name, if_not_exists: true
+        conn.add_index :dependency_snapshots, :ecosystem, if_not_exists: true
+      end
+
+      def self.optimize_for_bulk_writes
+        conn = ActiveRecord::Base.connection
+        conn.execute("PRAGMA synchronous = OFF")
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA cache_size = -64000") # 64MB cache
+      end
+
+      def self.optimize_for_reads
+        conn = ActiveRecord::Base.connection
+        conn.execute("PRAGMA synchronous = NORMAL")
+      end
+
+      def self.drop(git_dir = nil)
+        ActiveRecord::Base.connection.close if ActiveRecord::Base.connected?
+        File.delete(path(git_dir)) if exists?(git_dir)
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/branch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class Branch < ActiveRecord::Base
+        has_many :branch_commits, dependent: :destroy
+        has_many :commits, through: :branch_commits
+
+        validates :name, presence: true, uniqueness: true
+
+        def self.find_or_create(name)
+          find_or_create_by(name: name)
+        end
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/branch_commit.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class BranchCommit < ActiveRecord::Base
+        belongs_to :branch
+        belongs_to :commit
+
+        validates :branch_id, uniqueness: { scope: :commit_id }
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/commit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class Commit < ActiveRecord::Base
+        has_many :branch_commits, dependent: :destroy
+        has_many :branches, through: :branch_commits
+        has_many :dependency_changes, dependent: :destroy
+        has_many :dependency_snapshots, dependent: :destroy
+
+        validates :sha, presence: true, uniqueness: true
+
+        def self.find_or_create_from_rugged(rugged_commit)
+          find_or_create_by(sha: rugged_commit.oid) do |commit|
+            commit.message = rugged_commit.message&.strip
+            commit.author_name = rugged_commit.author[:name]
+            commit.author_email = rugged_commit.author[:email]
+            commit.committed_at = rugged_commit.time
+          end
+        end
+
+        def short_sha
+          sha[0, 7]
+        end
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/dependency_change.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class DependencyChange < ActiveRecord::Base
+        belongs_to :commit
+        belongs_to :manifest
+
+        validates :name, presence: true
+        validates :change_type, presence: true, inclusion: { in: %w[added modified removed] }
+
+        scope :added, -> { where(change_type: "added") }
+        scope :modified, -> { where(change_type: "modified") }
+        scope :removed, -> { where(change_type: "removed") }
+        scope :for_package, ->(name) { where(name: name) }
+        scope :for_platform, ->(platform) { where(ecosystem: platform) }
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/dependency_snapshot.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class DependencySnapshot < ActiveRecord::Base
+        belongs_to :commit
+        belongs_to :manifest
+
+        validates :name, presence: true
+
+        scope :for_package, ->(name) { where(name: name) }
+        scope :for_platform, ->(platform) { where(ecosystem: platform) }
+        scope :at_commit, ->(commit) { where(commit: commit) }
+
+        def self.current_for_branch(branch)
+          return none unless branch.last_analyzed_sha
+
+          commit = Commit.find_by(sha: branch.last_analyzed_sha)
+          return none unless commit
+
+          where(commit: commit)
+        end
+      end
+    end
+  end
+end

data/lib/git/pkgs/models/manifest.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Models
+      class Manifest < ActiveRecord::Base
+        has_many :dependency_changes, dependent: :destroy
+        has_many :dependency_snapshots, dependent: :destroy
+
+        validates :path, presence: true
+
+        def self.find_or_create(path:, ecosystem:, kind:)
+          find_or_create_by(path: path) do |m|
+            m.ecosystem = ecosystem
+            m.kind = kind
+          end
+        end
+      end
+    end
+  end
+end