git-pkgs 0.1.0

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class List
+        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)
+
+          commit_sha = @options[:commit] || repo.head_sha
+          target_commit = Models::Commit.find_by(sha: commit_sha)
+
+          unless target_commit
+            $stderr.puts "Commit #{commit_sha[0, 7]} not found in database"
+            exit 1
+          end
+
+          deps = compute_dependencies_at_commit(target_commit, repo)
+
+          if deps.empty?
+            puts "No dependencies found"
+            return
+          end
+
+          # Apply filters
+          if @options[:ecosystem]
+            deps = deps.select { |d| d[:ecosystem] == @options[:ecosystem] }
+          end
+
+          if @options[:type]
+            deps = deps.select { |d| d[:dependency_type] == @options[:type] }
+          end
+
+          if @options[:format] == "json"
+            require "json"
+            puts JSON.pretty_generate(deps)
+          else
+            grouped = deps.group_by { |d| [d[:manifest_path], d[:ecosystem]] }
+
+            grouped.each do |(path, platform), manifest_deps|
+              puts "#{path} (#{platform}):"
+              manifest_deps.sort_by { |d| d[:name] }.each do |dep|
+                type_suffix = dep[:dependency_type] ? " [#{dep[:dependency_type]}]" : ""
+                puts "  #{dep[:name]} #{dep[:requirement]}#{type_suffix}"
+              end
+              puts
+            end
+          end
+        end
+
+        def compute_dependencies_at_commit(target_commit, repo)
+          branch_name = @options[:branch] || repo.default_branch
+          branch = Models::Branch.find_by(name: branch_name)
+          return [] unless branch
+
+          # Find the nearest snapshot commit before or at target
+          snapshot_commit = branch.commits
+            .joins(:dependency_snapshots)
+            .where("commits.committed_at <= ?", target_commit.committed_at)
+            .order(committed_at: :desc)
+            .distinct
+            .first
+
+          # Build initial state from snapshot
+          deps = {}
+          if snapshot_commit
+            snapshot_commit.dependency_snapshots.includes(:manifest).each do |s|
+              key = [s.manifest.path, s.name]
+              deps[key] = {
+                manifest_path: s.manifest.path,
+                name: s.name,
+                ecosystem: s.ecosystem,
+                requirement: s.requirement,
+                dependency_type: s.dependency_type
+              }
+            end
+          end
+
+          # Replay changes from snapshot to target
+          if snapshot_commit && snapshot_commit.id != target_commit.id
+            changes = Models::DependencyChange
+              .joins(:commit, :manifest)
+              .where(commits: { id: branch.commit_ids })
+              .where("commits.committed_at > ? AND commits.committed_at <= ?",
+                     snapshot_commit.committed_at, target_commit.committed_at)
+              .order("commits.committed_at ASC")
+              .includes(:manifest)
+
+            changes.each do |change|
+              key = [change.manifest.path, change.name]
+              case change.change_type
+              when "added", "modified"
+                deps[key] = {
+                  manifest_path: change.manifest.path,
+                  name: change.name,
+                  ecosystem: change.ecosystem,
+                  requirement: change.requirement,
+                  dependency_type: change.dependency_type
+                }
+              when "removed"
+                deps.delete(key)
+              end
+            end
+          end
+
+          deps.values
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs list [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 (npm, rubygems, etc.)") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-t", "--type=TYPE", "Filter by dependency type") do |v|
+              options[:type] = v
+            end
+
+            opts.on("-b", "--branch=NAME", "Branch context for finding snapshots") 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/outdated.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Outdated
+        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&.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
+
+          # Find last update for each dependency
+          outdated_data = []
+
+          snapshots.each do |snapshot|
+            last_change = Models::DependencyChange
+              .includes(:commit)
+              .where(name: snapshot.name, manifest: snapshot.manifest)
+              .order("commits.committed_at DESC")
+              .first
+
+            next unless last_change
+
+            days_since_update = ((Time.now - last_change.commit.committed_at) / 86400).to_i
+
+            outdated_data << {
+              name: snapshot.name,
+              ecosystem: snapshot.ecosystem,
+              requirement: snapshot.requirement,
+              manifest: snapshot.manifest.path,
+              last_updated: last_change.commit.committed_at,
+              days_ago: days_since_update,
+              change_type: last_change.change_type
+            }
+          end
+
+          # Sort by days since last update (oldest first)
+          outdated_data.sort_by! { |d| -d[:days_ago] }
+
+          if @options[:days]
+            outdated_data = outdated_data.select { |d| d[:days_ago] >= @options[:days] }
+          end
+
+          if outdated_data.empty?
+            puts "All dependencies have been updated recently"
+            return
+          end
+
+          puts "Dependencies by last update:"
+          puts
+
+          max_name_len = outdated_data.map { |d| d[:name].length }.max
+          max_version_len = outdated_data.map { |d| d[:requirement].to_s.length }.max
+
+          outdated_data.each do |dep|
+            date = dep[:last_updated].strftime("%Y-%m-%d")
+            days = "#{dep[:days_ago]} days ago"
+            puts "#{dep[:name].ljust(max_name_len)}  #{dep[:requirement].to_s.ljust(max_version_len)}  #{date}  (#{days})"
+          end
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs outdated [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("-d", "--days=N", Integer, "Only show deps not updated in N days") do |v|
+              options[:days] = 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/search.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Search
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          pattern = @args.first
+
+          unless pattern
+            $stderr.puts "Usage: git pkgs search <pattern>"
+            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)
+
+          # Search for dependencies matching the pattern
+          query = Models::DependencyChange
+            .joins(:manifest)
+            .where("dependency_changes.name LIKE ?", "%#{pattern}%")
+
+          if @options[:ecosystem]
+            query = query.where(ecosystem: @options[:ecosystem])
+          end
+
+          if @options[:direct]
+            query = query.where(manifests: { kind: "manifest" })
+          end
+
+          # Get unique dependency names
+          matches = query.distinct.pluck(:name, :ecosystem)
+
+          if matches.empty?
+            puts "No dependencies found matching '#{pattern}'"
+            return
+          end
+
+          if @options[:format] == "json"
+            output_json(matches, pattern)
+          else
+            output_text(matches, pattern)
+          end
+        end
+
+        def output_text(matches, pattern)
+          puts "Dependencies matching '#{pattern}':"
+          puts
+
+          matches.group_by { |_, platform| platform }.each do |platform, deps|
+            puts "#{platform}:"
+            deps.each do |name, _|
+              summary = dependency_summary(name, platform)
+              puts "  #{name}"
+              puts "    #{summary}"
+            end
+            puts
+          end
+        end
+
+        def output_json(matches, pattern)
+          require "json"
+
+          results = matches.map do |name, platform|
+            changes = Models::DependencyChange
+              .where(name: name, ecosystem: platform)
+              .includes(:commit)
+              .order("commits.committed_at ASC")
+
+            first = changes.first
+            last = changes.last
+            current = changes.where(change_type: %w[added modified]).last
+
+            {
+              name: name,
+              ecosystem: platform,
+              first_seen: first&.commit&.committed_at&.iso8601,
+              last_changed: last&.commit&.committed_at&.iso8601,
+              current_version: current&.requirement,
+              removed: changes.last&.change_type == "removed",
+              total_changes: changes.count
+            }
+          end
+
+          puts JSON.pretty_generate(results)
+        end
+
+        def dependency_summary(name, platform)
+          changes = Models::DependencyChange
+            .where(name: name, ecosystem: platform)
+            .includes(:commit)
+            .order("commits.committed_at ASC")
+
+          first = changes.first
+          last = changes.last
+
+          parts = []
+          parts << "added #{first.commit.committed_at.strftime('%Y-%m-%d')}"
+
+          if last.change_type == "removed"
+            parts << "removed #{last.commit.committed_at.strftime('%Y-%m-%d')}"
+          else
+            current = changes.where(change_type: %w[added modified]).last
+            parts << "current: #{current&.requirement || 'unknown'}"
+          end
+
+          parts << "#{changes.count} changes"
+          parts.join(", ")
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs search <pattern> [options]"
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-d", "--direct", "Only show direct dependencies (not from lockfiles)") do
+              options[:direct] = true
+            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/stats.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Stats
+        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)
+
+          data = collect_stats(branch, branch_name)
+
+          if @options[:format] == "json"
+            require "json"
+            puts JSON.pretty_generate(data)
+          else
+            output_text(data)
+          end
+        end
+
+        def collect_stats(branch, branch_name)
+          data = {
+            branch: branch_name,
+            commits_analyzed: branch&.commits&.count || 0,
+            commits_with_changes: branch&.commits&.where(has_dependency_changes: true)&.count || 0,
+            current_dependencies: {},
+            changes: {},
+            most_changed: [],
+            manifests: []
+          }
+
+          if branch&.last_analyzed_sha
+            current_commit = Models::Commit.find_by(sha: branch.last_analyzed_sha)
+            snapshots = current_commit&.dependency_snapshots || []
+
+            data[:current_dependencies] = {
+              total: snapshots.count,
+              by_platform: snapshots.group(:ecosystem).count,
+              by_type: snapshots.group(:dependency_type).count
+            }
+          end
+
+          data[:changes] = {
+            total: Models::DependencyChange.count,
+            by_type: Models::DependencyChange.group(:change_type).count
+          }
+
+          most_changed = Models::DependencyChange
+            .group(:name, :ecosystem)
+            .order("count_all DESC")
+            .limit(10)
+            .count
+
+          data[:most_changed] = most_changed.map do |(name, ecosystem), count|
+            { name: name, ecosystem: ecosystem, changes: count }
+          end
+
+          data[:manifests] = Models::Manifest.all.map do |manifest|
+            { path: manifest.path, ecosystem: manifest.ecosystem, changes: manifest.dependency_changes.count }
+          end
+
+          data
+        end
+
+        def output_text(data)
+          puts "Dependency Statistics"
+          puts "=" * 40
+          puts
+
+          puts "Branch: #{data[:branch]}"
+          puts "Commits analyzed: #{data[:commits_analyzed]}"
+          puts "Commits with changes: #{data[:commits_with_changes]}"
+          puts
+
+          if data[:current_dependencies][:total]
+            puts "Current Dependencies"
+            puts "-" * 20
+            puts "Total: #{data[:current_dependencies][:total]}"
+
+            data[:current_dependencies][:by_platform].sort_by { |_, c| -c }.each do |ecosystem, count|
+              puts "  #{ecosystem}: #{count}"
+            end
+
+            by_type = data[:current_dependencies][:by_type]
+            if by_type.keys.compact.any?
+              puts
+              puts "By type:"
+              by_type.sort_by { |_, c| -c }.each do |type, count|
+                puts "  #{type || 'unknown'}: #{count}"
+              end
+            end
+          end
+
+          puts
+          puts "Dependency Changes"
+          puts "-" * 20
+          puts "Total changes: #{data[:changes][:total]}"
+          data[:changes][:by_type].each do |type, count|
+            puts "  #{type}: #{count}"
+          end
+
+          puts
+          puts "Most Changed Dependencies"
+          puts "-" * 25
+          data[:most_changed].each do |dep|
+            puts "  #{dep[:name]} (#{dep[:ecosystem]}): #{dep[:changes]} changes"
+          end
+
+          puts
+          puts "Manifest Files"
+          puts "-" * 14
+          data[:manifests].each do |m|
+            puts "  #{m[:path]} (#{m[:ecosystem]}): #{m[:changes]} changes"
+          end
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs stats [options]"
+
+            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