git-jump 0.1.0

data/lib/git_jump/database.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module GitJump
+  # Handles SQLite database operations for branch tracking
+  class Database
+    attr_reader :db_path
+
+    def initialize(db_path)
+      @db_path = db_path
+      @db = nil
+    end
+
+    # Lazy-load database connection
+    def db
+      @db ||= begin
+        require "sqlite3" unless defined?(SQLite3)
+        ensure_database_directory!
+        connection = SQLite3::Database.new(db_path)
+        connection.results_as_hash = true
+        migrate!(connection)
+        connection
+      end
+    end
+
+    def migrate!(connection)
+      connection.execute <<-SQL
+        CREATE TABLE IF NOT EXISTS projects (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          path TEXT NOT NULL UNIQUE,
+          basename TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+      SQL
+
+      connection.execute <<-SQL
+        CREATE TABLE IF NOT EXISTS branches (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          project_id INTEGER NOT NULL,
+          name TEXT NOT NULL,
+          position INTEGER NOT NULL DEFAULT 0,
+          last_visited_at TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+          UNIQUE(project_id, name)
+        );
+      SQL
+
+      connection.execute <<-SQL
+        CREATE INDEX IF NOT EXISTS idx_branches_project_position#{" "}
+          ON branches(project_id, position);
+      SQL
+    end
+
+    def find_or_create_project(path, basename)
+      project = db.execute(
+        "SELECT * FROM projects WHERE path = ?",
+        [path]
+      ).first
+
+      return project if project
+
+      now = Time.now.iso8601(3)
+      db.execute(
+        "INSERT INTO projects (path, basename, created_at, updated_at) VALUES (?, ?, ?, ?)",
+        [path, basename, now, now]
+      )
+
+      db.execute("SELECT * FROM projects WHERE path = ?", [path]).first
+    end
+
+    def add_branch(project_id, branch_name)
+      now = Time.now.iso8601(3)
+
+      # Try to insert, if already exists, update last_visited_at
+      db.execute(
+        <<-SQL,
+          INSERT INTO branches (project_id, name, position, last_visited_at, created_at)
+          VALUES (?, ?, 0, ?, ?)
+          ON CONFLICT(project_id, name) DO UPDATE SET
+            last_visited_at = ?,
+            position = 0
+        SQL
+        [project_id, branch_name, now, now, now]
+      )
+
+      # Reorder positions based on last_visited_at
+      reorder_branches(project_id)
+    end
+
+    def list_branches(project_id, limit: nil)
+      sql = "SELECT * FROM branches WHERE project_id = ? ORDER BY position ASC, last_visited_at DESC"
+      sql += " LIMIT ?" if limit
+
+      params = limit ? [project_id, limit] : [project_id]
+      db.execute(sql, params)
+    end
+
+    def next_branch(project_id, current_branch)
+      branches = list_branches(project_id)
+      return nil if branches.empty?
+
+      current_index = branches.index { |b| b["name"] == current_branch }
+
+      if current_index.nil?
+        branches.first["name"]
+      elsif current_index == branches.length - 1
+        branches.first["name"]
+      else
+        branches[current_index + 1]["name"]
+      end
+    end
+
+    def branch_at_index(project_id, index)
+      branches = list_branches(project_id)
+      return nil if branches.empty? || index < 1 || index > branches.length
+
+      branches[index - 1]["name"]
+    end
+
+    def clear_branches(project_id, keep_patterns)
+      return 0 if keep_patterns.empty?
+
+      branches = list_branches(project_id)
+      deleted = 0
+
+      branches.each do |branch|
+        branch_name = branch["name"]
+        should_keep = keep_patterns.any? { |pattern| branch_name.match?(Regexp.new(pattern)) }
+
+        unless should_keep
+          db.execute("DELETE FROM branches WHERE id = ?", [branch["id"]])
+          deleted += 1
+        end
+      end
+
+      reorder_branches(project_id)
+      deleted
+    end
+
+    def cleanup_old_branches(project_id, max_count)
+      branches = list_branches(project_id)
+      return 0 if branches.length <= max_count
+
+      to_delete = branches[max_count..]
+      to_delete.each do |branch|
+        db.execute("DELETE FROM branches WHERE id = ?", [branch["id"]])
+      end
+
+      reorder_branches(project_id)
+      to_delete.length
+    end
+
+    def count_branches(project_id)
+      db.execute(
+        "SELECT COUNT(*) as count FROM branches WHERE project_id = ?",
+        [project_id]
+      ).first["count"]
+    end
+
+    def project_stats(project_id)
+      {
+        total_branches: count_branches(project_id),
+        most_recent: list_branches(project_id, limit: 1).first
+      }
+    end
+
+    def close
+      db&.close
+    end
+
+    private
+
+    def ensure_database_directory!
+      dir = File.dirname(db_path)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+    end
+
+    def reorder_branches(project_id)
+      branches = db.execute(
+        "SELECT id FROM branches WHERE project_id = ? ORDER BY last_visited_at DESC",
+        [project_id]
+      )
+
+      branches.each_with_index do |branch, index|
+        db.execute("UPDATE branches SET position = ? WHERE id = ?", [index, branch["id"]])
+      end
+    end
+  end
+end

data/lib/git_jump/hooks/post_checkout.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GitJump
+  module Hooks
+    # Post-checkout hook implementation
+    class PostCheckout
+      attr_reader :repository_path
+
+      def initialize(repository_path)
+        @repository_path = repository_path
+      end
+
+      def run
+        repository = Repository.new(repository_path)
+        config = Config.new
+
+        return unless config.auto_track?
+
+        database = Database.new(config.database_path)
+        project = database.find_or_create_project(
+          repository.project_path,
+          repository.project_basename
+        )
+
+        current_branch = repository.current_branch
+        return unless current_branch && !current_branch.empty?
+
+        database.add_branch(project["id"], current_branch)
+
+        # Cleanup old branches if exceeded max
+        total = database.count_branches(project["id"])
+        database.cleanup_old_branches(project["id"], config.max_branches) if total > config.max_branches
+
+        database.close
+      rescue StandardError
+        # Silent fail in hooks to avoid interrupting git operations
+        nil
+      end
+    end
+  end
+end

data/lib/git_jump/loaders/add_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loader for add action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../database"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/add"

data/lib/git_jump/loaders/clear_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loader for clear action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../database"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/clear"

data/lib/git_jump/loaders/install_loader.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Loader for install action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/install"

data/lib/git_jump/loaders/jump_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loader for jump action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../database"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/jump"

data/lib/git_jump/loaders/list_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loader for list action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../database"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/list"

data/lib/git_jump/loaders/setup_loader.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Minimal loader for setup action - no database needed
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../actions/base"
+require_relative "../actions/setup"

data/lib/git_jump/loaders/status_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Loader for status action
+require_relative "../version"
+require_relative "../utils/xdg"
+require_relative "../utils/output"
+require_relative "../config"
+require_relative "../database"
+require_relative "../repository"
+require_relative "../actions/base"
+require_relative "../actions/status"

data/lib/git_jump/repository.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "English"
+require "fileutils"
+require "shellwords"
+
+module GitJump
+  # Wrapper for git repository operations
+  class Repository
+    class NotAGitRepositoryError < StandardError; end
+
+    attr_reader :path
+
+    def initialize(path = Dir.pwd)
+      @path = File.expand_path(path)
+      raise NotAGitRepositoryError, "Not a git repository: #{@path}" unless valid?
+    end
+
+    def valid?
+      git_dir = File.join(@path, ".git")
+      File.directory?(git_dir) || find_git_root
+    end
+
+    def project_path
+      @project_path ||= find_git_root || @path
+    end
+
+    def project_basename
+      File.basename(project_path)
+    end
+
+    def current_branch
+      result = execute_git("branch", "--show-current")
+      result.strip
+    rescue StandardError
+      nil
+    end
+
+    def branches
+      result = execute_git("branch", "--format=%(refname:short)")
+      result.split("\n").map(&:strip)
+    rescue StandardError
+      []
+    end
+
+    def checkout(branch_name)
+      # Set environment variable to skip git-jump hook during checkout
+      # This prevents double-loading of gems when git-jump triggers checkout
+      ENV["GIT_JUMP_SKIP_HOOK"] = "1"
+      execute_git("checkout", branch_name)
+      true
+    rescue StandardError => e
+      raise "Failed to checkout branch '#{branch_name}': #{e.message}"
+    ensure
+      ENV.delete("GIT_JUMP_SKIP_HOOK")
+    end
+
+    def branch_exists?(branch_name)
+      branches.include?(branch_name)
+    end
+
+    def hook_path(hook_name)
+      File.join(project_path, ".git", "hooks", hook_name)
+    end
+
+    def install_hook(hook_name, content)
+      path = hook_path(hook_name)
+      hooks_dir = File.dirname(path)
+
+      # Create hooks directory if it doesn't exist
+      FileUtils.mkdir_p(hooks_dir) unless File.directory?(hooks_dir)
+
+      File.write(path, content)
+      FileUtils.chmod(0o755, path)
+
+      true
+    rescue StandardError => e
+      raise "Failed to install hook '#{hook_name}': #{e.message}"
+    end
+
+    def hook_installed?(hook_name)
+      path = hook_path(hook_name)
+      File.exist?(path) && File.executable?(path)
+    end
+
+    def read_hook(hook_name)
+      File.read(hook_path(hook_name))
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def find_git_root
+      current = @path
+
+      loop do
+        return current if File.directory?(File.join(current, ".git"))
+
+        parent = File.dirname(current)
+        break if parent == current # reached root
+
+        current = parent
+      end
+
+      nil
+    end
+
+    def execute_git(*args)
+      Dir.chdir(project_path) do
+        cmd = ["git"] + args
+        output = `#{cmd.map(&:shellescape).join(" ")} 2>&1`
+        raise "Git command failed: #{output}" unless $CHILD_STATUS.success?
+
+        output
+      end
+    end
+  end
+end

data/lib/git_jump/utils/config_cache.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "fileutils"
+
+module GitJump
+  module Utils
+    # Caches parsed TOML configuration for faster startup
+    # Inspired by dotsync's ConfigCache implementation
+    class ConfigCache
+      attr_reader :config_path, :cache_dir, :cache_file, :meta_file
+
+      def initialize(config_path)
+        @config_path = File.expand_path(config_path)
+        @cache_dir = File.join(Utils::XDG.data_home, "git-jump", "config_cache")
+
+        # Use hash of real path for cache filename to support multiple configs
+        cache_key = Digest::SHA256.hexdigest(File.exist?(@config_path) ? File.realpath(@config_path) : @config_path)
+        @cache_file = File.join(@cache_dir, "#{cache_key}.cache")
+        @meta_file = File.join(@cache_dir, "#{cache_key}.meta")
+      end
+
+      def load
+        # Skip cache if disabled via environment variable
+        return parse_toml if ENV["GIT_JUMP_NO_CACHE"]
+
+        return parse_and_cache unless valid_cache?
+
+        # Fast path: load from cache
+        Marshal.load(File.binread(@cache_file))
+      rescue StandardError
+        # Fallback: reparse if cache corrupted or any error
+        parse_and_cache
+      end
+
+      private
+
+      def valid_cache?
+        return false unless File.exist?(@cache_file)
+        return false unless File.exist?(@meta_file)
+        return false unless File.exist?(@config_path)
+
+        meta = JSON.parse(File.read(@meta_file))
+        source_stat = File.stat(@config_path)
+
+        # Quick validation checks
+        return false if source_stat.mtime.to_f != meta["source_mtime"]
+        return false if source_stat.size != meta["source_size"]
+        return false if meta["git_jump_version"] != GitJump::VERSION
+
+        # Age check (invalidate cache older than 7 days for safety)
+        cache_age_days = (Time.now.to_f - meta["cached_at"]) / 86_400
+        return false if cache_age_days > 7
+
+        true
+      rescue StandardError
+        # Any error in validation means invalid cache
+        false
+      end
+
+      def parse_and_cache
+        config = parse_toml
+
+        # Write cache files
+        FileUtils.mkdir_p(@cache_dir)
+        File.binwrite(@cache_file, Marshal.dump(config))
+        File.write(@meta_file, JSON.generate(build_metadata))
+
+        config
+      rescue StandardError
+        # If caching fails, still return the parsed config
+        config
+      end
+
+      def parse_toml
+        require "toml-rb" unless defined?(TomlRB)
+        TomlRB.load_file(@config_path)
+      end
+
+      def build_metadata
+        source_stat = File.stat(@config_path)
+        {
+          source_path: @config_path,
+          source_size: source_stat.size,
+          source_mtime: source_stat.mtime.to_f,
+          cached_at: Time.now.to_f,
+          git_jump_version: GitJump::VERSION
+        }
+      end
+    end
+  end
+end

data/lib/git_jump/utils/output.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "../colors"
+
+module GitJump
+  module Utils
+    # Handles formatted console output with colors and tables
+    class Output
+      attr_reader :quiet, :verbose
+
+      def initialize(quiet: false, verbose: false)
+        @quiet = quiet
+        @verbose = verbose
+      end
+
+      def success(message)
+        puts Colors.green("✓ #{message}") unless quiet
+      end
+
+      def error(message)
+        warn Colors.red("✗ #{message}")
+      end
+
+      def warning(message)
+        puts Colors.yellow("⚠ #{message}") unless quiet
+      end
+
+      def info(message)
+        puts Colors.blue("ℹ #{message}") unless quiet
+      end
+
+      def debug(message)
+        puts Colors.dim(message) if verbose
+      end
+
+      def heading(message)
+        puts unless quiet
+        puts Colors.cyan(message, bold: true) unless quiet
+        puts Colors.dim("─" * message.length) unless quiet
+      end
+
+      def table(headers, rows)
+        return if quiet
+
+        require "terminal-table" unless defined?(Terminal::Table)
+        table = Terminal::Table.new(headings: headers, rows: rows)
+        puts table
+      end
+
+      def branch_list(branches, current_branch)
+        return if quiet || branches.empty?
+
+        heading("Tracked Branches")
+
+        rows = branches.map.with_index(1) do |branch, index|
+          name = branch["name"]
+          marker = name == current_branch ? Colors.green("→") : " "
+          styled_name = name == current_branch ? Colors.green(name, bold: true) : name
+          last_visited = format_time(branch["last_visited_at"])
+
+          ["#{marker} #{index}", styled_name, last_visited]
+        end
+
+        table(["#", "Branch", "Last Visited"], rows)
+      end
+
+      def prompt(message, _default: "N")
+        return true if quiet # Auto-confirm in quiet mode
+
+        print Colors.yellow("#{message} [y/N] ")
+        answer = $stdin.gets&.chomp&.downcase
+        %w[y yes].include?(answer)
+      end
+
+      private
+
+      def format_time(time_string)
+        time = Time.parse(time_string)
+        diff = Time.now - time
+
+        case diff
+        when 0..59
+          "just now"
+        when 60..3599
+          "#{(diff / 60).to_i}m ago"
+        when 3600..86_399
+          "#{(diff / 3600).to_i}h ago"
+        when 86_400..2_591_999
+          "#{(diff / 86_400).to_i}d ago"
+        else
+          time.strftime("%Y-%m-%d")
+        end
+      rescue StandardError
+        "unknown"
+      end
+    end
+  end
+end

data/lib/git_jump/utils/xdg.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module GitJump
+  module Utils
+    # XDG Base Directory Specification support
+    # https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+    module XDG
+      class << self
+        def config_home
+          ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config"))
+        end
+
+        def data_home
+          ENV.fetch("XDG_DATA_HOME", File.join(Dir.home, ".local", "share"))
+        end
+
+        def cache_home
+          ENV.fetch("XDG_CACHE_HOME", File.join(Dir.home, ".cache"))
+        end
+
+        def config_path(custom_path = nil)
+          return custom_path if custom_path
+
+          File.join(config_home, "git-jump", "config.toml")
+        end
+
+        def database_path
+          File.join(data_home, "git-jump", "branches.db")
+        end
+
+        def ensure_directories!
+          [config_dir, data_dir, cache_dir].each do |dir|
+            FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          end
+        end
+
+        private
+
+        def config_dir
+          File.join(config_home, "git-jump")
+        end
+
+        def data_dir
+          File.join(data_home, "git-jump")
+        end
+
+        def cache_dir
+          File.join(cache_home, "git-jump")
+        end
+      end
+    end
+  end
+end

data/lib/git_jump/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GitJump
+  VERSION = "0.1.0"
+end