git-pkgs 0.2.0 → 0.4.0

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

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Update
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -11,21 +13,14 @@ module Git
 
         def run
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           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
+          error "Branch '#{branch_name}' not in database. Run 'git pkgs init --branch=#{branch_name}' first." unless branch
 
           since_sha = branch.last_analyzed_sha
           current_sha = repo.branch_target(branch_name)
@@ -62,60 +57,62 @@ module Git
           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
+          ActiveRecord::Base.transaction do
+            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]
+                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
-          end
 
-          branch.update(last_analyzed_sha: current_sha)
+            branch.update(last_analyzed_sha: current_sha)
+          end
 
           puts "\nDone!"
           puts "Processed #{total} new commits"

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Upgrade
+        include Output
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          repo = Repository.new
+          require_database(repo)
+
+          Database.connect(repo.git_dir, check_version: false)
+
+          stored = Database.stored_version || 0
+          current = Database::SCHEMA_VERSION
+
+          if stored >= current
+            puts "Database is up to date (version #{current})"
+            return
+          end
+
+          puts "Upgrading database from version #{stored} to #{current}..."
+          puts "This requires re-indexing the repository."
+          puts
+
+          # Run init --force
+          Init.new(["--force"]).run
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs upgrade [options]"
+
+            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/where.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Git
+  module Pkgs
+    module Commands
+      class Where
+        include Output
+
+        def initialize(args)
+          @args = args
+          @options = parse_options
+        end
+
+        def run
+          name = @args.first
+
+          error "Usage: git pkgs where <package-name>" unless name
+
+          repo = Repository.new
+          require_database(repo)
+
+          Database.connect(repo.git_dir)
+
+          workdir = File.dirname(repo.git_dir)
+          branch = Models::Branch.find_by(name: @options[:branch] || repo.default_branch)
+
+          unless branch
+            error "Branch not found. Run 'git pkgs init' first."
+          end
+
+          snapshots = Models::DependencySnapshot.current_for_branch(branch)
+          snapshots = snapshots.where(ecosystem: @options[:ecosystem]) if @options[:ecosystem]
+
+          manifest_paths = snapshots.for_package(name).joins(:manifest).pluck("manifests.path").uniq
+
+          if manifest_paths.empty?
+            empty_result "Package '#{name}' not found in current dependencies"
+            return
+          end
+
+          results = manifest_paths.flat_map do |path|
+            find_in_manifest(name, File.join(workdir, path), path)
+          end
+
+          if results.empty?
+            empty_result "Package '#{name}' tracked but not found in current files"
+            return
+          end
+
+          if @options[:format] == "json"
+            output_json(results)
+          else
+            paginate { output_text(results, name) }
+          end
+        end
+
+        def find_in_manifest(name, full_path, display_path)
+          return [] unless File.exist?(full_path)
+
+          lines = File.readlines(full_path)
+          matches = []
+
+          lines.each_with_index do |line, idx|
+            next unless line.include?(name)
+
+            match = { path: display_path, line: idx + 1, content: line.rstrip }
+
+            if context_lines > 0
+              match[:before] = context_before(lines, idx)
+              match[:after] = context_after(lines, idx)
+            end
+
+            matches << match
+          end
+
+          matches
+        end
+
+        def context_lines
+          @options[:context] || 0
+        end
+
+        def context_before(lines, idx)
+          start_idx = [0, idx - context_lines].max
+          (start_idx...idx).map { |i| { line: i + 1, content: lines[i].rstrip } }
+        end
+
+        def context_after(lines, idx)
+          end_idx = [lines.length - 1, idx + context_lines].min
+          ((idx + 1)..end_idx).map { |i| { line: i + 1, content: lines[i].rstrip } }
+        end
+
+        def output_text(results, name)
+          results.each_with_index do |result, i|
+            puts "--" if i > 0 && context_lines > 0
+
+            result[:before]&.each do |ctx|
+              puts format_context_line(result[:path], ctx[:line], ctx[:content])
+            end
+
+            puts format_match_line(result[:path], result[:line], result[:content], name)
+
+            result[:after]&.each do |ctx|
+              puts format_context_line(result[:path], ctx[:line], ctx[:content])
+            end
+          end
+        end
+
+        def format_match_line(path, line_num, content, name)
+          path_str = Color.magenta(path)
+          line_str = Color.green(line_num.to_s)
+          highlighted = content.gsub(name, Color.red(name))
+          "#{path_str}:#{line_str}:#{highlighted}"
+        end
+
+        def format_context_line(path, line_num, content)
+          path_str = Color.magenta(path)
+          line_str = Color.green(line_num.to_s)
+          content_str = Color.dim(content)
+          "#{path_str}-#{line_str}-#{content_str}"
+        end
+
+        def output_json(results)
+          require "json"
+          puts JSON.pretty_generate(results)
+        end
+
+        def parse_options
+          options = {}
+
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: git pkgs where <package-name> [options]"
+
+            opts.on("-b", "--branch=NAME", "Branch to search (default: current)") do |v|
+              options[:branch] = v
+            end
+
+            opts.on("-e", "--ecosystem=NAME", "Filter by ecosystem") do |v|
+              options[:ecosystem] = v
+            end
+
+            opts.on("-C", "--context=NUM", Integer, "Show NUM lines of context") do |v|
+              options[:context] = v
+            end
+
+            opts.on("-f", "--format=FORMAT", "Output format (text, json)") do |v|
+              options[:format] = v
+            end
+
+            opts.on("--no-pager", "Do not pipe output into a pager") do
+              options[:no_pager] = 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/why.rb

@@ -4,6 +4,8 @@ module Git
   module Pkgs
     module Commands
       class Why
+        include Output
+
         def initialize(args)
           @args = args
           @options = parse_options
@@ -12,17 +14,10 @@ module Git
         def run
           package_name = @args.shift
 
-          unless package_name
-            $stderr.puts "Usage: git pkgs why <package>"
-            exit 1
-          end
+          error "Usage: git pkgs why <package>" unless package_name
 
           repo = Repository.new
-
-          unless Database.exists?(repo.git_dir)
-            $stderr.puts "Database not initialized. Run 'git pkgs init' first."
-            exit 1
-          end
+          require_database(repo)
 
           Database.connect(repo.git_dir)
 
@@ -40,7 +35,7 @@ module Git
           added_change = added_change.first
 
           unless added_change
-            puts "Package '#{package_name}' not found in dependency history"
+            empty_result "Package '#{package_name}' not found in dependency history"
             return
           end
 

data/lib/git/pkgs/database.rb

@@ -7,13 +7,24 @@ module Git
   module Pkgs
     class Database
       DB_FILE = "pkgs.sqlite3"
+      SCHEMA_VERSION = 1
 
       def self.path(git_dir = nil)
+        return ENV["GIT_PKGS_DB"] if ENV["GIT_PKGS_DB"] && !ENV["GIT_PKGS_DB"].empty?
+
         git_dir ||= find_git_dir
         File.join(git_dir, DB_FILE)
       end
 
       def self.find_git_dir
+        # Respect GIT_DIR environment variable
+        if ENV["GIT_DIR"] && !ENV["GIT_DIR"].empty?
+          git_dir = ENV["GIT_DIR"]
+          return git_dir if File.directory?(git_dir)
+
+          raise NotInGitRepoError, "GIT_DIR '#{git_dir}' does not exist"
+        end
+
         dir = Dir.pwd
         loop do
           git_dir = File.join(dir, ".git")
@@ -26,12 +37,13 @@ module Git
         end
       end
 
-      def self.connect(git_dir = nil)
+      def self.connect(git_dir = nil, check_version: true)
         db_path = path(git_dir)
         ActiveRecord::Base.establish_connection(
           adapter: "sqlite3",
           database: db_path
         )
+        check_version! if check_version
       end
 
       def self.connect_memory
@@ -48,6 +60,10 @@ module Git
 
       def self.create_schema(with_indexes: true)
         ActiveRecord::Schema.define do
+          create_table :schema_info, if_not_exists: true do |t|
+            t.integer :version, null: false
+          end
+
           create_table :branches, if_not_exists: true do |t|
             t.string :name, null: false
             t.string :last_analyzed_sha
@@ -104,6 +120,7 @@ module Git
           end
         end
 
+        set_version
         create_bulk_indexes if with_indexes
       end
 
@@ -122,6 +139,43 @@ module Git
         conn.add_index :dependency_snapshots, :ecosystem, if_not_exists: true
       end
 
+      def self.stored_version
+        conn = ActiveRecord::Base.connection
+        return nil unless conn.table_exists?(:schema_info)
+
+        result = conn.select_value("SELECT version FROM schema_info LIMIT 1")
+        result&.to_i
+      end
+
+      def self.set_version(version = SCHEMA_VERSION)
+        conn = ActiveRecord::Base.connection
+        conn.execute("DELETE FROM schema_info")
+        conn.execute("INSERT INTO schema_info (version) VALUES (#{version})")
+      end
+
+      def self.needs_upgrade?
+        conn = ActiveRecord::Base.connection
+
+        # No tables at all = fresh database, no upgrade needed
+        return false unless conn.table_exists?(:commits)
+
+        # Has commits table but no schema_info = old database, needs upgrade
+        return true unless conn.table_exists?(:schema_info)
+
+        # Check version
+        stored = stored_version || 0
+        stored < SCHEMA_VERSION
+      end
+
+      def self.check_version!
+        return unless needs_upgrade?
+
+        stored = stored_version || 0
+        $stderr.puts "Database schema is outdated (version #{stored}, current is #{SCHEMA_VERSION})."
+        $stderr.puts "Run 'git pkgs upgrade' to update."
+        exit 1
+      end
+
       def self.optimize_for_bulk_writes
         conn = ActiveRecord::Base.connection
         conn.execute("PRAGMA synchronous = OFF")

data/lib/git/pkgs/output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "pager"
+
+module Git
+  module Pkgs
+    module Output
+      include Pager
+      # Print error message and exit with code 1.
+      # Use for user errors (bad input, invalid refs) and system errors (db missing).
+      # When format is :json, outputs JSON to stdout; otherwise outputs text to stderr.
+      def error(msg, format: nil)
+        format ||= @options[:format] if defined?(@options) && @options.is_a?(Hash)
+
+        if format == "json"
+          puts JSON.generate({ error: msg })
+        else
+          $stderr.puts msg
+        end
+        exit 1
+      end
+
+      # Print informational message for "no results" cases.
+      # When format is :json, outputs empty JSON array/object; otherwise outputs text.
+      def empty_result(msg, format: nil, json_value: [])
+        format ||= @options[:format] if defined?(@options) && @options.is_a?(Hash)
+
+        if format == "json"
+          puts JSON.generate(json_value)
+        else
+          puts msg
+        end
+      end
+
+      # Standard check for database existence.
+      def require_database(repo)
+        return if Database.exists?(repo.git_dir)
+
+        error "Database not initialized. Run 'git pkgs init' first."
+      end
+    end
+  end
+end

data/lib/git/pkgs/pager.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Git
+  module Pkgs
+    module Pager
+      # Returns the pager command following git's precedence:
+      # 1. GIT_PAGER environment variable
+      # 2. core.pager git config
+      # 3. PAGER environment variable
+      # 4. less as fallback
+      def git_pager
+        return ENV["GIT_PAGER"] if ENV["GIT_PAGER"] && !ENV["GIT_PAGER"].empty?
+
+        config_pager = `git config --get core.pager`.chomp
+        return config_pager unless config_pager.empty?
+
+        return ENV["PAGER"] if ENV["PAGER"] && !ENV["PAGER"].empty?
+
+        "less -FRSX"
+      end
+
+      # Returns true if paging is disabled (pager set to empty string or 'cat')
+      def pager_disabled?
+        pager = git_pager
+        pager.empty? || pager == "cat"
+      end
+
+      # Captures output from a block and sends it through the pager.
+      # Falls back to direct output if:
+      # - stdout is not a TTY
+      # - pager is disabled
+      # - pager command fails
+      def paginate
+        if !$stdout.tty? || pager_disabled? || paging_disabled?
+          yield
+          return
+        end
+
+        output = StringIO.new
+        old_stdout = $stdout
+        $stdout = output
+
+        begin
+          yield
+        ensure
+          $stdout = old_stdout
+        end
+
+        content = output.string
+        return if content.empty?
+
+        IO.popen(git_pager, "w") { |io| io.write(content) }
+      rescue Errno::EPIPE
+        # User quit pager early
+      rescue Errno::ENOENT
+        # Pager command not found, fall back to direct output
+        print content
+      end
+
+      # Check if paging was disabled via --no-pager option
+      def paging_disabled?
+        defined?(@options) && @options.is_a?(Hash) && @options[:no_pager]
+      end
+    end
+  end
+end

data/lib/git/pkgs/repository.rb

@@ -7,9 +7,9 @@ module Git
     class Repository
       attr_reader :path
 
-      def initialize(path = Dir.pwd)
-        @path = path
-        @rugged = Rugged::Repository.new(path)
+      def initialize(path = nil)
+        @path = path || ENV["GIT_DIR"] || Dir.pwd
+        @rugged = Rugged::Repository.new(@path)
       end
 
       def git_dir

data/lib/git/pkgs/version.rb

@@ -2,6 +2,6 @@
 
 module Git
   module Pkgs
-    VERSION = "0.2.0"
+    VERSION = "0.4.0"
   end
 end

data/lib/git/pkgs.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "pkgs/version"
+require_relative "pkgs/output"
+require_relative "pkgs/color"
 require_relative "pkgs/cli"
 require_relative "pkgs/database"
 require_relative "pkgs/repository"
@@ -21,13 +23,18 @@ require_relative "pkgs/commands/list"
 require_relative "pkgs/commands/history"
 require_relative "pkgs/commands/why"
 require_relative "pkgs/commands/blame"
-require_relative "pkgs/commands/outdated"
+require_relative "pkgs/commands/stale"
 require_relative "pkgs/commands/stats"
 require_relative "pkgs/commands/diff"
 require_relative "pkgs/commands/tree"
 require_relative "pkgs/commands/branch"
 require_relative "pkgs/commands/search"
 require_relative "pkgs/commands/show"
+require_relative "pkgs/commands/where"
+require_relative "pkgs/commands/log"
+require_relative "pkgs/commands/upgrade"
+require_relative "pkgs/commands/schema"
+require_relative "pkgs/commands/diff_driver"
 
 module Git
   module Pkgs