worktree_manager 0.2.1

data/lib/worktree_manager/config_manager.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module WorktreeManager
+  class ConfigManager
+    DEFAULT_CONFIG_FILES = [
+      '.worktree.yml',
+      '.git/.worktree.yml'
+    ].freeze
+
+    DEFAULT_WORKTREES_DIR = '../'
+    DEFAULT_MAIN_BRANCH_NAME = 'main'
+
+    def initialize(repository_path = '.')
+      @repository_path = File.expand_path(repository_path)
+      @config = load_config
+    end
+
+    def worktrees_dir
+      @config['worktrees_dir'] || DEFAULT_WORKTREES_DIR
+    end
+
+    def hooks
+      @config['hooks'] || {}
+    end
+
+    def main_branch_name
+      @config['main_branch_name'] || DEFAULT_MAIN_BRANCH_NAME
+    end
+
+    def resolve_worktree_path(name_or_path)
+      # If it's an absolute path, return as is
+      return name_or_path if name_or_path.start_with?('/')
+
+      # If it contains a path separator, treat it as a relative path
+      return File.expand_path(name_or_path, @repository_path) if name_or_path.include?('/')
+
+      # Otherwise, use worktrees_dir as the base
+      base_dir = File.expand_path(worktrees_dir, @repository_path)
+      File.join(base_dir, name_or_path)
+    end
+
+    private
+
+    def load_config
+      config_file = find_config_file
+      return {} unless config_file
+
+      begin
+        YAML.load_file(config_file) || {}
+      rescue StandardError => e
+        puts "Warning: Failed to load config file #{config_file}: #{e.message}"
+        {}
+      end
+    end
+
+    def find_config_file
+      DEFAULT_CONFIG_FILES.each do |file|
+        path = File.join(@repository_path, file)
+        return path if File.exist?(path)
+      end
+      nil
+    end
+  end
+end

data/lib/worktree_manager/hook_manager.rb

@@ -0,0 +1,269 @@
+require 'yaml'
+require 'open3'
+
+module WorktreeManager
+  class HookManager
+    HOOK_TYPES = %w[pre_add post_add pre_remove post_remove].freeze
+    DEFAULT_HOOK_FILES = [
+      '.worktree.yml',
+      '.git/.worktree.yml'
+    ].freeze
+
+    def initialize(repository_path = '.', verbose: false)
+      @repository_path = File.expand_path(repository_path)
+      @verbose = verbose
+      @hooks = load_hooks
+    end
+
+    def execute_hook(hook_type, context = {})
+      log_debug("🪝 Starting hook execution: #{hook_type}")
+
+      return true unless HOOK_TYPES.include?(hook_type.to_s)
+      return true unless @hooks.key?(hook_type.to_s)
+
+      hook_config = @hooks[hook_type.to_s]
+      return true if hook_config.nil? || hook_config.empty?
+
+      log_debug("📋 Hook configuration: #{hook_config.inspect}")
+      log_debug("🔧 Context: #{context.inspect}")
+
+      result = case hook_config
+               when String
+                 execute_command(hook_config, context, hook_type)
+               when Array
+                 hook_config.all? { |command| execute_command(command, context, hook_type) }
+               when Hash
+                 execute_hook_hash(hook_config, context, hook_type)
+               else
+                 true
+               end
+
+      log_debug("✅ Hook execution completed: #{hook_type} (result: #{result})")
+      result
+    end
+
+    def has_hook?(hook_type)
+      HOOK_TYPES.include?(hook_type.to_s) &&
+        @hooks.key?(hook_type.to_s) &&
+        !@hooks[hook_type.to_s].nil?
+    end
+
+    def list_hooks
+      @hooks.select { |type, config| HOOK_TYPES.include?(type) && !config.nil? }
+    end
+
+    private
+
+    def load_hooks
+      hook_file = find_hook_file
+      return {} unless hook_file
+
+      begin
+        config = YAML.load_file(hook_file) || {}
+        # Support new structure: read configuration under hooks key
+        if config.key?('hooks')
+          config['hooks']
+        else
+          # Support top-level keys for backward compatibility
+          config
+        end
+      rescue StandardError => e
+        puts "Warning: Failed to load hook file #{hook_file}: #{e.message}"
+        {}
+      end
+    end
+
+    def find_hook_file
+      DEFAULT_HOOK_FILES.each do |file|
+        path = File.join(@repository_path, file)
+        return path if File.exist?(path)
+      end
+      nil
+    end
+
+    def execute_command(command, context, hook_type = nil, working_dir = nil)
+      log_debug("🚀 Executing command: #{command}")
+
+      env = build_env_vars(context)
+      log_debug("🌍 Environment variables: #{env.select { |k, _| k.start_with?('WORKTREE_') }}")
+
+      # Determine working directory
+      chdir = working_dir || default_working_directory(hook_type, context)
+      log_debug("📂 Working directory: #{chdir}")
+
+      start_time = Time.now
+      status = nil
+
+      # Execute command with environment variables and stream output
+      begin
+        if env && !env.empty?
+          # Verify environment variable is a Hash
+          log_debug("🔍 Environment variable type: #{env.class}")
+          log_debug("🔍 Environment variable sample: #{env.first(3).to_h}")
+
+          # Use popen3 for streaming output
+          Open3.popen3(env, 'sh', '-c', command, chdir: chdir) do |stdin, stdout, stderr, wait_thr|
+            stdin.close
+
+            # Create threads to read both stdout and stderr concurrently
+            threads = []
+
+            threads << Thread.new do
+              stdout.each_line do |line|
+                print line
+                STDOUT.flush
+              end
+            end
+
+            threads << Thread.new do
+              stderr.each_line do |line|
+                STDERR.print line
+                STDERR.flush
+              end
+            end
+
+            # Wait for all threads to complete
+            threads.each(&:join)
+
+            # Wait for the process to complete
+            status = wait_thr.value
+          end
+        else
+          Open3.popen3(command, chdir: chdir) do |stdin, stdout, stderr, wait_thr|
+            stdin.close
+
+            # Create threads to read both stdout and stderr concurrently
+            threads = []
+
+            threads << Thread.new do
+              stdout.each_line do |line|
+                print line
+                STDOUT.flush
+              end
+            end
+
+            threads << Thread.new do
+              stderr.each_line do |line|
+                STDERR.print line
+                STDERR.flush
+              end
+            end
+
+            # Wait for all threads to complete
+            threads.each(&:join)
+
+            # Wait for the process to complete
+            status = wait_thr.value
+          end
+        end
+      rescue StandardError => e
+        log_debug("❌ Open3.popen3 error: #{e.class} - #{e.message}")
+        raise
+      end
+
+      duration = Time.now - start_time
+      log_debug("⏱️ Execution time: #{(duration * 1000).round(2)}ms")
+
+      unless status.success?
+        puts "Hook failed: #{command}"
+        log_debug("❌ Command execution failed: exit code #{status.exitstatus}")
+        return false
+      end
+
+      log_debug('✅ Command executed successfully')
+      true
+    end
+
+    def execute_hook_hash(hook_config, context, hook_type)
+      # Support new structure
+      commands = hook_config['commands'] || hook_config[:commands]
+      single_command = hook_config['command'] || hook_config[:command]
+      pwd = hook_config['pwd'] || hook_config[:pwd]
+      stop_on_error = hook_config.fetch('stop_on_error', true)
+
+      # Substitute environment variables if pwd is set
+      if pwd
+        pwd = pwd.gsub(/\$([A-Z_]+)/) do |match|
+          var_name = ::Regexp.last_match(1)
+          # First look for environment variables
+          if var_name == 'WORKTREE_ABSOLUTE_PATH' && context[:path]
+            path = context[:path]
+            path.start_with?('/') ? path : File.expand_path(path, @repository_path)
+          elsif %w[WORKTREE_MAIN WORKTREE_MANAGER_ROOT].include?(var_name)
+            @repository_path
+          elsif var_name.start_with?('WORKTREE_')
+            context_key = var_name.sub('WORKTREE_', '').downcase.to_sym
+            context[context_key]
+          else
+            ENV[var_name] || match
+          end
+        end
+      end
+
+      if commands && commands.is_a?(Array)
+        # Process commands array
+        commands.each do |cmd|
+          result = execute_command(cmd, context, hook_type, pwd)
+          return false if !result && stop_on_error
+        end
+        true
+      elsif single_command
+        # Process single command (backward compatibility)
+        execute_command(single_command, context, hook_type, pwd)
+      else
+        true
+      end
+    end
+
+    def build_env_vars(context)
+      # Copy only necessary environment variables instead of ENV.to_h
+      env = {}
+
+      # Copy only basic environment variables (PATH, etc.)
+      %w[PATH HOME USER SHELL].each do |key|
+        env[key] = ENV[key] if ENV[key]
+      end
+
+      # Default environment variables
+      env['WORKTREE_MANAGER_ROOT'] = @repository_path
+      env['WORKTREE_MAIN'] = @repository_path # Main repository path
+
+      # Context-based environment variables
+      context.each do |key, value|
+        env_key = "WORKTREE_#{key.to_s.upcase}"
+        env[env_key] = value.to_s
+      end
+
+      # Add worktree absolute path
+      if context[:path]
+        path = context[:path]
+        abs_path = path.start_with?('/') ? path : File.expand_path(path, @repository_path)
+        env['WORKTREE_ABSOLUTE_PATH'] = abs_path
+      end
+
+      env
+    end
+
+    def default_working_directory(hook_type, context)
+      # post_add and pre_remove run in worktree directory by default
+      if %w[post_add pre_remove].include?(hook_type.to_s) && context[:path]
+        # Convert relative path to absolute path
+        path = context[:path]
+        if path.start_with?('/')
+          path
+        else
+          File.expand_path(path, @repository_path)
+        end
+      else
+        @repository_path
+      end
+    end
+
+    def log_debug(message)
+      return unless @verbose
+
+      timestamp = Time.now.strftime('%H:%M:%S.%3N')
+      puts "[#{timestamp}] [DEBUG] #{message}"
+    end
+  end
+end

data/lib/worktree_manager/manager.rb

@@ -0,0 +1,126 @@
+require 'open3'
+require_relative 'worktree'
+
+module WorktreeManager
+  class Manager
+    attr_reader :repository_path
+
+    def initialize(repository_path = '.')
+      @repository_path = File.expand_path(repository_path)
+      validate_git_repository!
+    end
+
+    def list
+      output, status = execute_git_command('worktree list --porcelain')
+      return [] unless status.success?
+
+      parse_worktree_list(output)
+    end
+
+    def add(path, branch = nil, force: false)
+      command = %w[worktree add]
+      command << '--force' if force
+      command << path
+      command << branch if branch
+
+      output, status = execute_git_command(command.join(' '))
+      raise Error, output unless status.success?
+
+      # Return created worktree information
+      worktree_info = { path: path }
+      worktree_info[:branch] = branch if branch
+      Worktree.new(worktree_info)
+    end
+
+    def add_with_new_branch(path, branch, force: false)
+      command = %w[worktree add]
+      command << '--force' if force
+      command << '-b' << branch
+      command << path
+
+      output, status = execute_git_command(command.join(' '))
+      raise Error, output unless status.success?
+
+      # Return created worktree information
+      Worktree.new(path: path, branch: branch)
+    end
+
+    def add_tracking_branch(path, local_branch, remote_branch, force: false)
+      # Fetch the remote branch first
+      remote, branch_name = remote_branch.split('/', 2)
+      fetch_output, fetch_status = execute_git_command("fetch #{remote} #{branch_name}")
+      raise Error, "Failed to fetch remote branch: #{fetch_output}" unless fetch_status.success?
+
+      # Create worktree with new branch tracking the remote
+      command = %w[worktree add]
+      command << '--force' if force
+      command << '-b' << local_branch
+      command << path
+      command << "#{remote_branch}"
+
+      output, status = execute_git_command(command.join(' '))
+      raise Error, output unless status.success?
+
+      # Return created worktree information
+      Worktree.new(path: path, branch: local_branch)
+    end
+
+    def remove(path, force: false)
+      command = %w[worktree remove]
+      command << '--force' if force
+      command << path
+
+      output, status = execute_git_command(command.join(' '))
+      raise Error, output unless status.success?
+
+      true
+    end
+
+    def prune
+      output, status = execute_git_command('worktree prune')
+      raise Error, output unless status.success?
+
+      true
+    end
+
+    private
+
+    def validate_git_repository!
+      return if File.directory?(File.join(@repository_path, '.git'))
+
+      raise Error, "Not a git repository: #{@repository_path}"
+    end
+
+    def execute_git_command(command)
+      full_command = "git -C #{@repository_path} #{command}"
+      Open3.capture2e(full_command)
+    end
+
+    def parse_worktree_list(output)
+      worktrees = []
+      current_worktree = {}
+
+      output.lines.each do |line|
+        line.strip!
+        next if line.empty?
+
+        case line
+        when /^worktree (.+)$/
+          worktrees << Worktree.new(current_worktree) unless current_worktree.empty?
+          current_worktree = { path: ::Regexp.last_match(1) }
+        when /^HEAD (.+)$/
+          current_worktree[:head] = ::Regexp.last_match(1)
+        when /^branch (.+)$/
+          current_worktree[:branch] = ::Regexp.last_match(1)
+        when /^detached$/
+          current_worktree[:detached] = true
+        when /^bare$/
+          current_worktree[:bare] = true
+        end
+      end
+
+      worktrees << Worktree.new(current_worktree) unless current_worktree.empty?
+      worktrees
+    end
+  end
+end

data/lib/worktree_manager/version.rb

@@ -0,0 +1,3 @@
+module WorktreeManager
+  VERSION = File.read(File.join(File.dirname(__FILE__), '../../.version')).strip
+end

data/lib/worktree_manager/worktree.rb

@@ -0,0 +1,56 @@
+module WorktreeManager
+  class Worktree
+    attr_reader :path, :branch, :head, :detached, :bare
+
+    def initialize(attributes = {})
+      case attributes
+      when Hash
+        @path = attributes[:path]
+        @branch = attributes[:branch]
+        @head = attributes[:head]
+        @detached = attributes[:detached] || false
+        @bare = attributes[:bare] || false
+      when String
+        @path = attributes
+        @branch = nil
+        @head = nil
+        @detached = false
+        @bare = false
+      end
+    end
+
+    def detached?
+      @detached
+    end
+
+    def bare?
+      @bare
+    end
+
+    def main?
+      @branch == 'main' || @branch == 'master'
+    end
+
+    def exists?
+      File.directory?(@path)
+    end
+
+    def to_s
+      if @branch
+        "#{@path} (#{@branch})"
+      else
+        "#{@path} (#{@head})"
+      end
+    end
+
+    def to_h
+      {
+        path: @path,
+        branch: @branch,
+        head: @head,
+        detached: @detached,
+        bare: @bare
+      }
+    end
+  end
+end

data/lib/worktree_manager.rb

@@ -0,0 +1,11 @@
+require_relative 'worktree_manager/version'
+require_relative 'worktree_manager/manager'
+require_relative 'worktree_manager/worktree'
+
+module WorktreeManager
+  class Error < StandardError; end
+
+  def self.new(repository_path = '.')
+    Manager.new(repository_path)
+  end
+end

data/mise/release.sh

@@ -0,0 +1,120 @@
+#!/bin/bash
+
+set -e
+
+# Set default version increment if not provided
+VERSION_INCREMENT="${1:-0.0.1}"
+
+# Validate version increment format
+if [[ ! "$VERSION_INCREMENT" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    echo "Error: Version increment must be in format X.Y.Z (e.g., 0.0.1)"
+    exit 1
+fi
+
+# Change to the project root directory
+cd "$(dirname "$0")/.."
+
+# Check if git repository is clean
+if [ -n "$(git status --porcelain)" ]; then
+    echo "Error: Git repository is not clean. Please commit or stash your changes."
+    git status --short
+    exit 1
+fi
+
+# Clean up old gem files
+echo "Cleaning up old gem files..."
+rm -f worktree_manager-*.gem
+
+# Read current version from .version file
+if [ ! -f .version ]; then
+    echo "Error: .version file not found"
+    exit 1
+fi
+
+CURRENT_VERSION=$(cat .version)
+echo "Current version: $CURRENT_VERSION"
+
+# Parse version components
+IFS='.' read -ra CURRENT_PARTS <<< "$CURRENT_VERSION"
+IFS='.' read -ra INCREMENT_PARTS <<< "$VERSION_INCREMENT"
+
+# Validate current version format
+if [ ${#CURRENT_PARTS[@]} -ne 3 ]; then
+    echo "Error: Current version must be in format X.Y.Z"
+    exit 1
+fi
+
+# Calculate new version
+MAJOR=$((CURRENT_PARTS[0] + INCREMENT_PARTS[0]))
+MINOR=$((CURRENT_PARTS[1] + INCREMENT_PARTS[1]))
+PATCH=$((CURRENT_PARTS[2] + INCREMENT_PARTS[2]))
+
+# Handle carry-over
+if [ $PATCH -ge 10 ]; then
+    MINOR=$((MINOR + PATCH / 10))
+    PATCH=$((PATCH % 10))
+fi
+
+if [ $MINOR -ge 10 ]; then
+    MAJOR=$((MAJOR + MINOR / 10))
+    MINOR=$((MINOR % 10))
+fi
+
+NEW_VERSION="$MAJOR.$MINOR.$PATCH"
+echo "New version: $NEW_VERSION"
+
+# Update .version file FIRST
+echo "$NEW_VERSION" > .version
+
+# Update Gemfile.lock with new version
+echo "Updating Gemfile.lock..."
+bundle install
+
+# Build the gem with new version
+echo "Building gem with version $NEW_VERSION..."
+if gem build worktree_manager.gemspec; then
+    echo "Gem built successfully: worktree_manager-$NEW_VERSION.gem"
+    
+    # Git operations
+    echo "Committing version bump..."
+    git add .version Gemfile.lock
+    git commit -m "Bump version to $NEW_VERSION"
+    
+    echo "Creating git tag..."
+    git tag -a "v$NEW_VERSION" -m "Release version $NEW_VERSION"
+    
+    echo "Pushing to remote..."
+    git push origin
+    git push origin "v$NEW_VERSION"
+    
+    # Ask about publishing to RubyGems.org
+    echo ""
+    read -p "Publish to RubyGems.org? (y/N): " publish_confirm
+    
+    if [[ "$publish_confirm" =~ ^[Yy]$ ]]; then
+        echo "Publishing to RubyGems.org..."
+        if gem push worktree_manager-$NEW_VERSION.gem; then
+            echo "✓ Gem published successfully to RubyGems.org"
+            echo ""
+            echo "View your gem at: https://rubygems.org/gems/worktree_manager"
+        else
+            echo "Error: RubyGems.org push failed"
+            echo "You can manually publish with:"
+            echo "  gem push worktree_manager-$NEW_VERSION.gem"
+            exit 1
+        fi
+    else
+        echo "Skipping RubyGems.org publishing."
+        echo "You can manually publish later with:"
+        echo "  gem push worktree_manager-$NEW_VERSION.gem"
+    fi
+    
+    echo "Release complete!"
+    echo "Version $NEW_VERSION has been released."
+else
+    echo "Error: Gem build failed with new version"
+    # Revert version change
+    echo "$CURRENT_VERSION" > .version
+    bundle install  # Revert Gemfile.lock
+    exit 1
+fi