git-jump 0.1.0

data/lib/git_jump/actions/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GitJump
+  module Actions
+    # Base class for all actions
+    class Base
+      attr_reader :config, :database, :repository, :output
+
+      def initialize(config:, database:, repository:, output:)
+        @config = config
+        @database = database
+        @repository = repository
+        @output = output
+      end
+
+      def execute
+        raise NotImplementedError, "#{self.class} must implement #execute"
+      end
+
+      private
+
+      def project
+        @project ||= database.find_or_create_project(
+          repository.project_path,
+          repository.project_basename
+        )
+      end
+
+      def project_id
+        project["id"]
+      end
+    end
+  end
+end

data/lib/git_jump/actions/clear.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module GitJump
+  module Actions
+    # Action to clear branches matching keep patterns
+    class Clear < Base
+      def execute
+        branches = database.list_branches(project_id)
+
+        if branches.empty?
+          output.info("No branches tracked for #{repository.project_basename}")
+          return true
+        end
+
+        keep_patterns = config.keep_patterns(repository.project_path)
+
+        if keep_patterns.empty?
+          output.warning("No keep patterns configured. All branches would be deleted.")
+          output.info("Configure keep_patterns in your config file to use this command")
+          return false
+        end
+
+        output.info("Keep patterns: #{keep_patterns.join(", ")}")
+
+        unless output.prompt("Clear branches not matching patterns?")
+          output.info("Cancelled")
+          return false
+        end
+
+        deleted = database.clear_branches(project_id, keep_patterns)
+
+        if deleted.zero?
+          output.info("No branches to clear (all match keep patterns)")
+        else
+          output.success("Cleared #{deleted} branch(es)")
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/git_jump/actions/install.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module GitJump
+  module Actions
+    # Action to install post-checkout git hook
+    class Install < Base
+      HOOK_TEMPLATE = <<~BASH.freeze
+        #!/bin/sh
+        # Git Jump post-checkout hook
+        # Auto-generated - do not edit manually
+
+        PREV_HEAD=$1
+        NEW_HEAD=$2
+        BRANCH_CHECKOUT=$3
+
+        # Skip if called from git-jump itself to avoid double-loading
+        if [ -n "$GIT_JUMP_SKIP_HOOK" ]; then
+            exit 0
+        fi
+
+        # Only run on branch checkouts (not file checkouts)
+        if [ "$BRANCH_CHECKOUT" = "1" ]; then
+            RUBY_PATH="$(which ruby)"
+        #{"    "}
+            if [ -z "$RUBY_PATH" ]; then
+                exit 0
+            fi
+        #{"    "}
+            "$RUBY_PATH" -e "
+              begin
+                require 'git_jump'
+                GitJump::Hooks::PostCheckout.new('$(pwd)').run
+              rescue LoadError
+                # Gem not available, skip silently
+              rescue => e
+                # Silent error handling in hook
+              end
+            " 2>/dev/null
+        fi
+      BASH
+
+      def execute
+        if repository.hook_installed?("post-checkout")
+          existing_content = repository.read_hook("post-checkout")
+
+          if existing_content&.include?("Git Jump post-checkout hook")
+            output.info("Git Jump hook already installed")
+            return true
+          else
+            output.warning("A post-checkout hook already exists")
+            return false unless output.prompt("Overwrite existing hook?")
+          end
+        end
+
+        repository.install_hook("post-checkout", HOOK_TEMPLATE)
+        output.success("Installed post-checkout hook in #{repository.project_basename}")
+        output.info("Branches will now be automatically tracked on checkout")
+
+        true
+      rescue StandardError => e
+        output.error("Failed to install hook: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/git_jump/actions/jump.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module GitJump
+  module Actions
+    # Action to jump to next branch or specific index
+    class Jump < Base
+      attr_reader :index
+
+      def initialize(index: nil, **)
+        super(**)
+        @index = index
+      end
+
+      def execute
+        branches = database.list_branches(project_id)
+
+        if branches.empty?
+          output.error("No branches tracked for #{repository.project_basename}")
+          output.info("Use 'git-jump add <branch>' to add branches")
+          return false
+        end
+
+        target_branch = if index
+                          database.branch_at_index(project_id, index.to_i)
+                        else
+                          current_branch = repository.current_branch
+                          database.next_branch(project_id, current_branch)
+                        end
+
+        unless target_branch
+          output.error("Invalid branch index: #{index}") if index
+          return false
+        end
+
+        if target_branch == repository.current_branch
+          output.info("Already on branch '#{target_branch}'")
+          return true
+        end
+
+        repository.checkout(target_branch)
+        database.add_branch(project_id, target_branch) # Update last_visited_at
+
+        output.success("Switched to branch '#{target_branch}'")
+        true
+      rescue StandardError => e
+        output.error(e.message)
+        false
+      end
+    end
+  end
+end

data/lib/git_jump/actions/list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module GitJump
+  module Actions
+    # Action to list tracked branches
+    class List < Base
+      def execute
+        branches = database.list_branches(project_id)
+
+        if branches.empty?
+          output.info("No branches tracked for #{repository.project_basename}")
+          output.info("Use 'git-jump add <branch>' to add branches or 'git-jump install' to setup automatic tracking")
+          return true
+        end
+
+        current_branch = repository.current_branch
+        output.branch_list(branches, current_branch)
+
+        true
+      end
+    end
+  end
+end

data/lib/git_jump/actions/setup.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GitJump
+  module Actions
+    # Action to initialize/setup configuration file
+    class Setup
+      attr_reader :config_path, :output
+
+      def initialize(output:, config_path: nil, **_options)
+        @config_path = config_path || Utils::XDG.config_path
+        @output = output
+      end
+
+      def execute
+        if File.exist?(@config_path)
+          output.warning("Config file already exists at: #{@config_path}")
+          return false unless output.prompt("Overwrite existing config?")
+        end
+
+        Utils::XDG.ensure_directories!
+
+        File.write(@config_path, Config.default_config_content)
+
+        output.success("Created config file at: #{@config_path}")
+        output.info("Edit this file to customize your branch tracking settings")
+
+        true
+      rescue StandardError => e
+        output.error("Failed to create config file: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/git_jump/actions/status.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module GitJump
+  module Actions
+    # Action to display current status and configuration
+    class Status < Base
+      def execute
+        output.heading("Git Jump Status")
+
+        output.info("Project: #{repository.project_basename}")
+        output.info("Path: #{repository.project_path}")
+        output.info("Current branch: #{repository.current_branch || "(none)"}")
+
+        output.heading("Configuration")
+        output.info("Config file: #{config.path}")
+        output.info("Config exists: #{config.exists? ? "Yes" : "No"}")
+        output.info("Database: #{config.database_path}")
+        output.info("Max branches: #{config.max_branches}")
+        output.info("Auto-track: #{config.auto_track? ? "Enabled" : "Disabled"}")
+        output.info("Keep patterns: #{config.keep_patterns.join(", ")}")
+
+        output.heading("Hook Status")
+        hook_installed = repository.hook_installed?("post-checkout")
+        output.info("Post-checkout hook: #{hook_installed ? "Installed" : "Not installed"}")
+
+        output.heading("Tracking Statistics")
+        stats = database.project_stats(project_id)
+        output.info("Total branches tracked: #{stats[:total_branches]}")
+
+        output.info("Most recent: #{stats[:most_recent]["name"]}") if stats[:most_recent]
+
+        true
+      end
+    end
+  end
+end

data/lib/git_jump/cli.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module GitJump
+  # Command-line interface using OptionParser
+  class CLI
+    def self.start(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      @global_options = { config: nil, quiet: false, verbose: false }
+
+      if argv.empty?
+        print_help
+        exit(0)
+      end
+
+      command = argv.shift
+
+      case command
+      when "setup"
+        setup_command(argv)
+      when "install"
+        install_command(argv)
+      when "add"
+        add_command(argv)
+      when "list"
+        list_command(argv)
+      when "jump"
+        jump_command(argv)
+      when "clear"
+        clear_command(argv)
+      when "status"
+        status_command(argv)
+      when "version", "-v", "--version"
+        version_command
+      when "help", "-h", "--help"
+        print_help
+      else
+        warn "Unknown command: #{command}"
+        warn "Run 'git-jump help' for usage information."
+        exit(1)
+      end
+    end
+
+    private
+
+    def setup_command(argv)
+      parse_global_options(argv)
+      require_relative "loaders/setup_loader"
+      output = create_output
+      action = GitJump::Actions::Setup.new(
+        config_path: @global_options[:config],
+        output: output
+      )
+      exit(1) unless action.execute
+    end
+
+    def install_command(argv)
+      parse_global_options(argv)
+      require_relative "loaders/install_loader"
+      action = create_action(GitJump::Actions::Install)
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def add_command(argv)
+      options = { verify: true }
+
+      parser = OptionParser.new do |opts|
+        parse_global_option_definitions(opts)
+        opts.on("--[no-]verify", "Verify branch exists (default: true)") do |v|
+          options[:verify] = v
+        end
+      end
+
+      parser.parse!(argv)
+      parse_global_options_from_parsed(parser)
+
+      if argv.empty?
+        warn "Error: BRANCH argument is required"
+        warn "Usage: git-jump add BRANCH [options]"
+        exit(1)
+      end
+
+      branch_name = argv.shift
+
+      require_relative "loaders/add_loader"
+      action = create_action(GitJump::Actions::Add, branch_name: branch_name, verify: options[:verify])
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def list_command(argv)
+      parse_global_options(argv)
+      require_relative "loaders/list_loader"
+      action = create_action(GitJump::Actions::List)
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def jump_command(argv)
+      parse_global_options(argv)
+      index = argv.shift
+
+      require_relative "loaders/jump_loader"
+      action = create_action(GitJump::Actions::Jump, index: index)
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def clear_command(argv)
+      parse_global_options(argv)
+      require_relative "loaders/clear_loader"
+      action = create_action(GitJump::Actions::Clear)
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def status_command(argv)
+      parse_global_options(argv)
+      require_relative "loaders/status_loader"
+      action = create_action(GitJump::Actions::Status)
+      exit(1) unless action.execute
+    rescue StandardError => e
+      handle_repository_error(e)
+    end
+
+    def version_command
+      require_relative "version" unless defined?(GitJump::VERSION)
+      puts "git-jump #{GitJump::VERSION}"
+    end
+
+    def parse_global_options(argv)
+      parser = OptionParser.new do |opts|
+        parse_global_option_definitions(opts)
+      end
+      parser.parse!(argv)
+      parse_global_options_from_parsed(parser)
+    end
+
+    def parse_global_option_definitions(opts)
+      opts.on("-c", "--config PATH", "Path to config file") do |c|
+        @global_options[:config] = c
+      end
+      opts.on("-q", "--quiet", "Suppress output") do
+        @global_options[:quiet] = true
+      end
+      opts.on("-v", "--verbose", "Verbose output") do
+        @global_options[:verbose] = true
+      end
+    end
+
+    def parse_global_options_from_parsed(_parser)
+      # Already set in parse_global_option_definitions callbacks
+    end
+
+    def print_help
+      puts <<~HELP
+        Usage: git-jump COMMAND [options]
+
+        Smart git branch tracker and switcher with SQLite persistence
+
+        Commands:
+          setup              Initialize configuration file
+          install            Install post-checkout git hook in current repository
+          add BRANCH         Manually add a branch to tracking
+          list               List tracked branches for current project
+          jump [INDEX]       Jump to next branch or specific index
+          clear              Clear branches not matching keep patterns
+          status             Show current status and configuration
+          version            Show version
+          help               Show this help message
+
+        Global Options:
+          -c, --config PATH  Path to config file
+          -q, --quiet        Suppress output
+          -v, --verbose      Verbose output
+
+        Examples:
+          git-jump setup                 # Initialize configuration
+          git-jump install               # Install git hook
+          git-jump add feature/new       # Add branch to tracking
+          git-jump list                  # Show tracked branches
+          git-jump jump                  # Jump to next branch
+          git-jump jump 3                # Jump to branch at index 3
+          git-jump clear                 # Clear old branches
+
+        For more information, visit: https://github.com/dsaenztagarro/git-jump
+      HELP
+    end
+
+    def create_output
+      require_relative "utils/output" unless defined?(Utils::Output)
+      Utils::Output.new(
+        quiet: @global_options[:quiet],
+        verbose: @global_options[:verbose]
+      )
+    end
+
+    def create_action(action_class, **extra_options)
+      # Dependencies are already loaded by action-specific loaders
+      output = create_output
+      config = Config.new(@global_options[:config])
+      repository = Repository.new
+      database = Database.new(config.database_path)
+
+      action_class.new(
+        config: config,
+        database: database,
+        repository: repository,
+        output: output,
+        **extra_options
+      )
+    end
+
+    def handle_repository_error(error)
+      # Check if it's a NotAGitRepositoryError without requiring it to be loaded
+      raise error unless error.class.name.end_with?("NotAGitRepositoryError")
+
+      create_output.error(error.message)
+      exit(1)
+    end
+  end
+end

data/lib/git_jump/colors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module GitJump
+  # Lightweight color module using ANSI escape codes
+  # Inspired by dotsync's approach - no external dependencies
+  module Colors
+    # ANSI color codes (256-color palette)
+    # Use \e[38;5;NNNm for foreground colors
+    # Use \e[1m for bold
+    # Use \e[0m to reset
+
+    GREEN = 34
+    RED = 196
+    YELLOW = 220
+    BLUE = 39
+    CYAN = 51
+    DIM = 242
+
+    module_function
+
+    def colorize(text, color:, bold: false)
+      codes = []
+      codes << "\e[38;5;#{color}m" if color
+      codes << "\e[1m" if bold
+      "#{codes.join}#{text}\e[0m"
+    end
+
+    def green(text, bold: false)
+      colorize(text, color: GREEN, bold: bold)
+    end
+
+    def red(text, bold: false)
+      colorize(text, color: RED, bold: bold)
+    end
+
+    def yellow(text, bold: false)
+      colorize(text, color: YELLOW, bold: bold)
+    end
+
+    def blue(text, bold: false)
+      colorize(text, color: BLUE, bold: bold)
+    end
+
+    def cyan(text, bold: false)
+      colorize(text, color: CYAN, bold: bold)
+    end
+
+    def dim(text)
+      colorize(text, color: DIM, bold: false)
+    end
+
+    def bold(text)
+      "\e[1m#{text}\e[0m"
+    end
+  end
+end

data/lib/git_jump/config.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module GitJump
+  # Manages configuration from TOML file
+  class Config
+    attr_reader :path, :data
+
+    DEFAULT_CONFIG = {
+      "database" => {
+        "path" => "$XDG_DATA_HOME/git-jump/branches.db"
+      },
+      "tracking" => {
+        "max_branches" => 20,
+        "auto_track" => true,
+        "keep_patterns" => ["^main$", "^master$", "^develop$", "^staging$"]
+      },
+      "projects" => []
+    }.freeze
+
+    def initialize(path = nil)
+      @path = Utils::XDG.config_path(path)
+      @data = load_config
+    end
+
+    # Cache the config instance per path to avoid reloading
+    @instances = {}
+
+    def self.instance(path = nil)
+      normalized_path = Utils::XDG.config_path(path)
+      @instances[normalized_path] ||= new(path)
+    end
+
+    def self.default_config_content
+      <<~TOML
+        [database]
+        # SQLite database location (defaults to XDG_DATA_HOME/git-jump/branches.db)
+        # You can use environment variables like $XDG_DATA_HOME or $HOME
+        path = "$XDG_DATA_HOME/git-jump/branches.db"
+
+        [tracking]
+        # Maximum number of branches to track per project
+        max_branches = 20
+
+        # Automatically track branches on checkout (via git hook)
+        auto_track = true
+
+        # Global branch patterns to always keep when clearing (regex patterns)
+        keep_patterns = ["^main$", "^master$", "^develop$", "^staging$"]
+
+        # Example project-specific configuration
+        # [[projects]]
+        # name = "my-project"
+        # path = "/path/to/my-project"
+        # keep_patterns = ["^main$", "^feature/.*$"]
+      TOML
+    end
+
+    def exists?
+      File.exist?(@path)
+    end
+
+    def database_path
+      expand_env_vars(data.dig("database", "path") || Utils::XDG.database_path)
+    end
+
+    def max_branches
+      data.dig("tracking", "max_branches") || 20
+    end
+
+    def auto_track?
+      data.dig("tracking", "auto_track") != false
+    end
+
+    def keep_patterns(project_path = nil)
+      # Check for project-specific patterns first
+      if project_path
+        project = find_project(project_path)
+        return project["keep_patterns"] if project && project["keep_patterns"]
+      end
+
+      # Fall back to global patterns
+      data.dig("tracking", "keep_patterns") || []
+    end
+
+    def find_project(project_path)
+      projects = data["projects"] || []
+      projects.find { |p| p["path"] == project_path }
+    end
+
+    private
+
+    def load_config
+      return DEFAULT_CONFIG unless File.exist?(@path)
+
+      require_relative "utils/config_cache" unless defined?(Utils::ConfigCache)
+      cache = Utils::ConfigCache.new(@path)
+      cache.load
+    rescue StandardError => e
+      warn "Error loading config file: #{e.message}"
+      warn "Using default configuration"
+      DEFAULT_CONFIG
+    end
+
+    def expand_env_vars(path)
+      return path unless path.is_a?(String)
+
+      path.gsub(/\$(\w+)/) do |match|
+        var_name = match[1..]
+        ENV.fetch(var_name, match)
+      end
+    end
+  end
+end