workbush 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 132934e2d49cc1ddb117f480bf1a25ec9a4a91fcabc24df1b43ff0b57d046aad
+  data.tar.gz: 03ac659ce226d284e40e02a3b343181eb07b3dd43f02c48175c8421559b196ae
+SHA512:
+  metadata.gz: 1ba2a27a705a2f695a076fe9f28fb6875945706c62131a8dea8fad2f7f51cdad05b7be4faad549dd34e3feee3bc4ec0226d32a444e713d692eec57a94067b5f1
+  data.tar.gz: 627bea0fc9628d829d184eb23c4d6530fe969badebb76a54904c6bc42df885be55ac5b46f1289664c0528038091a602577765120e617eafcdd0baab6baa90588

data/.workbush.yml.example

@@ -0,0 +1,39 @@
+# Workbush Configuration Example
+# Copy this file to .workbush.yml in your project root and customize as needed
+
+# Files to copy (exact paths relative to worktree root)
+copy_files:
+  - .env
+  - .env.local
+  - .env.development
+  - config/database.yml
+  - config/credentials.yml.enc
+
+# Glob patterns for copying multiple files
+# Use standard Ruby glob syntax
+copy_patterns:
+  - ".env.*"           # All .env.* files
+  - "*.lock"           # All lock files (Gemfile.lock, package-lock.json, etc.)
+  - "config/*.local"   # All .local config files
+
+# Directories to copy
+# Useful for dependencies that are expensive to reinstall
+copy_directories:
+  - node_modules       # Node.js dependencies
+  - vendor/bundle      # Ruby bundled gems
+  - .bundle            # Bundler configuration
+  - tmp/cache          # Application cache
+
+# Commands to run after worktree creation
+# These run in the new worktree directory
+post_create_commands:
+  - bundle install     # Install Ruby gems
+  - yarn install       # Install Node packages
+  - rails db:migrate   # Run database migrations
+
+# You can also use ERB templates for dynamic configuration:
+# copy_files:
+#   - <%= ENV.fetch("CONFIG_FILE", ".env") %>
+#
+# post_create_commands:
+#   - <%= ENV.fetch("SETUP_COMMAND", "bundle install") %>

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Oğulcan Girginç
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,248 @@
+# Workbush 🌳
+
+Manage git worktrees with automatic file copying and setup commands. Workbush simplifies the process of creating git worktrees by automatically copying dependencies, configuration files, and running setup commands based on a simple YAML configuration.
+
+## Why Workbush?
+
+Git worktrees are powerful for working on multiple branches simultaneously, but setting them up can be tedious:
+- Manually copying `.env` files
+- Re-running `bundle install` or `npm install`
+- Copying `node_modules` or `vendor/bundle` to avoid reinstalling
+- Running database migrations
+- Copying other configuration files
+
+Workbush automates all of this with a single command.
+
+## Features
+
+- **Automatic file copying**: Copy dependencies, configs, and build artifacts
+- **Post-creation commands**: Run setup commands automatically
+- **Glob pattern support**: Copy files matching patterns
+- **YAML configuration**: Simple, version-controlled setup
+- **ERB templates**: Dynamic configuration with environment variables
+- **Thor-based CLI**: Beautiful, colorized output
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install workbush
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem 'workbush'
+```
+
+## Quick Start
+
+1. **Initialize configuration** in your project:
+
+```bash
+workbush init
+```
+
+2. **Edit `.workbush.yml`** to match your needs:
+
+```yaml
+copy_files:
+  - .env
+  - .env.local
+  - mise.local.toml
+
+copy_directories:
+  - node_modules
+  - vendor/bundle
+
+post_create_commands:
+  - mise trust
+  - bundle install
+  - rails db:migrate
+```
+
+3. **Create a worktree** with automatic setup:
+
+```bash
+workbush add ../feature-123 feature-branch
+```
+
+That's it! Your new worktree is ready with all files copied and commands executed.
+
+## Usage
+
+### Create a worktree
+
+```bash
+# Create worktree for existing branch
+workbush add ../feature-123 feature-branch
+
+# Create worktree with new branch
+workbush add ../bug-fix new-branch-name
+
+# Create without copying files
+workbush add --no-copy ../quick-test main
+
+# Create without running commands
+workbush add --no-run-commands ../feature-456 feature-branch
+
+# Create with verbose output
+workbush add --verbose ../feature-789 feature-branch
+
+# Force creation (overwrite existing path)
+workbush add --force ../existing-path feature-branch
+```
+
+### List worktrees
+
+```bash
+workbush list
+```
+
+### Remove a worktree
+
+```bash
+# With confirmation prompt
+workbush remove ../feature-123
+
+# Force removal without confirmation
+workbush remove --force ../feature-123
+```
+
+### Initialize configuration
+
+```bash
+# Create .workbush.yml in current directory
+workbush init
+
+# Overwrite existing config
+workbush init --force
+```
+
+### Show version
+
+```bash
+workbush version
+```
+
+## Configuration
+
+Create a `.workbush.yml` file in your project root:
+
+```yaml
+# Files to copy (exact paths)
+copy_files:
+  - .env
+  - .env.local
+  - .env.development
+  - config/database.yml
+  - config/credentials.yml.enc
+
+# Glob patterns for multiple files
+copy_patterns:
+  - ".env.*"
+  - "*.lock"
+  - "config/*.local"
+
+# Directories to copy
+copy_directories:
+  - node_modules
+  - vendor/bundle
+  - .bundle
+  - tmp/cache
+
+# Commands to run after creation
+post_create_commands:
+  - bundle install
+  - yarn install
+  - rails db:migrate
+```
+
+### ERB Templates
+
+Use ERB for dynamic configuration:
+
+```yaml
+copy_files:
+  - <%= ENV.fetch("CONFIG_FILE", ".env") %>
+
+post_create_commands:
+  - <%= ENV.fetch("SETUP_COMMAND", "bundle install") %>
+```
+
+## Use Cases
+
+### Rails Development
+
+```yaml
+copy_files:
+  - .env
+  - mise.local.toml
+  - config/database.yml
+  - config/master.key
+
+copy_directories:
+  - vendor/bundle
+  - node_modules
+
+post_create_commands:
+  - mise trust
+  - bundle install
+  - yarn install
+  - rails db:migrate
+```
+
+### Node.js Projects
+
+```yaml
+copy_files:
+  - .env
+  - .env.local
+
+copy_directories:
+  - node_modules
+
+post_create_commands:
+  - npm install
+  - npm run build
+```
+
+### Ruby Gems
+
+```yaml
+copy_directories:
+  - vendor/bundle
+
+post_create_commands:
+  - bundle install
+```
+
+## Global Options
+
+All commands support these options:
+
+- `--verbose` or `-v`: Enable detailed output
+- `--config PATH` or `-c PATH`: Use custom config file
+
+## Tips
+
+1. **Commit your `.workbush.yml`**: Share configuration with your team
+2. **Copy `node_modules`**: Much faster than re-running `npm install`
+3. **Use glob patterns**: Copy all `.env.*` files at once
+4. **Skip commands when needed**: Use `--no-run-commands` for quick testing
+5. **Check the list**: Use `workbush list` to see all your worktrees
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/workbush.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"

data/exe/workbush

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "workbush"
+
+Workbush::CLI.start(ARGV)

data/lib/workbush/cli.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "config"
+require_relative "worktree"
+require_relative "file_copier"
+require_relative "command_runner"
+require_relative "errors"
+
+module Workbush
+  # Command-line interface for Workbush
+  class CLI < Thor
+    class_option :verbose, type: :boolean, aliases: "-v", desc: "Enable verbose output"
+    class_option :config, type: :string, aliases: "-c", desc: "Path to config file"
+
+    desc "add PATH [BRANCH]", "Create a new worktree with automatic setup"
+    long_desc <<~LONGDESC
+      Creates a git worktree at the specified PATH, optionally checking out BRANCH.
+
+      Automatically copies files and runs setup commands based on .workbush.yml configuration.
+
+      Examples:
+        # Create worktree for existing branch
+        $ workbush add ../feature-123 feature-branch
+
+        # Create worktree with new branch from current HEAD
+        $ workbush add ../bug-fix new-branch-name
+
+        # Create without copying files
+        $ workbush add --no-copy ../quick-test main
+
+        # Create with verbose output
+        $ workbush add --verbose ../feature-456 feature-branch
+    LONGDESC
+    method_option :copy, type: :boolean, default: true, desc: "Copy files from parent worktree"
+    method_option :run_commands, type: :boolean, default: true, desc: "Run post-creation commands"
+    method_option :force, type: :boolean, aliases: "-f", desc: "Force creation even if path exists"
+    def add(path, branch = nil)
+      config = load_config
+
+      # Create worktree
+      worktree = Worktree.new(path: path, branch: branch)
+      say "Creating worktree at #{path}...", :cyan
+      worktree.create(force: options[:force])
+      say "✓ Worktree created successfully", :green
+
+      # Copy files if enabled
+      if options[:copy] && has_copy_config?(config)
+        copy_files(worktree, config)
+      elsif options[:copy]
+        say "No copy configuration found, skipping file copy", :yellow if options[:verbose]
+      end
+
+      # Run commands if enabled
+      if options[:run_commands] && has_commands?(config)
+        run_commands(worktree, config)
+      elsif options[:run_commands]
+        say "No post-creation commands configured", :yellow if options[:verbose]
+      end
+
+      say
+      say "Worktree ready at: #{worktree.path}", :green
+      say "To switch to it: cd #{path}", :cyan
+    rescue GitError => e
+      say "Git error: #{e.message}", :red
+      exit 1
+    rescue WorktreeError => e
+      say "Worktree error: #{e.message}", :red
+      exit 1
+    rescue StandardError => e
+      say "Error: #{e.message}", :red
+      say e.backtrace.join("\n"), :red if options[:verbose]
+      exit 1
+    end
+
+    desc "init", "Create a .workbush.yml configuration file"
+    long_desc <<~LONGDESC
+      Creates a .workbush.yml configuration file in the current directory with example settings.
+
+      The configuration file defines:
+      - Files to copy from parent worktree
+      - Glob patterns for copying multiple files
+      - Directories to copy
+      - Commands to run after worktree creation
+
+      Example:
+        $ workbush init
+        $ vim .workbush.yml  # Edit to your needs
+    LONGDESC
+    method_option :force, type: :boolean, aliases: "-f", desc: "Overwrite existing config file"
+    def init
+      config_path = File.join(Dir.pwd, Config::DEFAULT_CONFIG_NAME)
+
+      if File.exist?(config_path) && !options[:force]
+        say "Configuration file already exists: #{config_path}", :yellow
+        return unless yes?("Overwrite?")
+      end
+
+      File.write(config_path, Config.default_template)
+      say "Created configuration file: #{config_path}", :green
+      say
+      say "Edit this file to customize your worktree setup:", :cyan
+      say "  #{config_path}"
+    rescue StandardError => e
+      say "Error creating config: #{e.message}", :red
+      exit 1
+    end
+
+    desc "list", "List all worktrees in the repository"
+    long_desc <<~LONGDESC
+      Lists all worktrees in the current git repository.
+
+      Shows the path, branch, and status for each worktree.
+
+      Example:
+        $ workbush list
+    LONGDESC
+    def list
+      worktrees = Worktree.list
+
+      if worktrees.empty?
+        say "No worktrees found", :yellow
+        return
+      end
+
+      say "Worktrees:", :cyan
+      worktrees.each do |wt|
+        branch_info = wt[:branch] || wt[:head]
+        status = []
+        status << "bare" if wt[:bare]
+        status << "detached" if wt[:detached]
+        status << "locked" if wt[:locked]
+
+        status_str = status.empty? ? "" : " (#{status.join(", ")})"
+        say "  #{wt[:path]} [#{branch_info}]#{status_str}"
+      end
+    rescue GitError => e
+      say "Git error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "remove PATH", "Remove a worktree"
+    long_desc <<~LONGDESC
+      Removes a worktree at the specified PATH.
+
+      By default, asks for confirmation before removing.
+      Use --force to skip confirmation and remove even if worktree is dirty.
+
+      Examples:
+        $ workbush remove ../feature-123
+        $ workbush remove --force ../old-branch
+    LONGDESC
+    method_option :force, type: :boolean, aliases: "-f", desc: "Force removal without confirmation"
+    def remove(path)
+      expanded_path = File.expand_path(path)
+
+      unless options[:force]
+        return unless yes?("Remove worktree at #{expanded_path}?")
+      end
+
+      Worktree.remove(expanded_path, force: options[:force])
+      say "✓ Worktree removed: #{expanded_path}", :green
+    rescue WorktreeError => e
+      say "Error: #{e.message}", :red
+      exit 1
+    end
+
+    desc "version", "Show Workbush version"
+    def version
+      say "Workbush version #{Workbush::VERSION}"
+    end
+
+    private
+
+    def load_config
+      Config.new(config_path: options[:config])
+    rescue ConfigError => e
+      say "Config error: #{e.message}", :red
+      exit 1
+    end
+
+    def has_copy_config?(config)
+      !config.copy_files.empty? ||
+        !config.copy_patterns.empty? ||
+        !config.copy_directories.empty?
+    end
+
+    def has_commands?(config)
+      !config.post_create_commands.empty?
+    end
+
+    def copy_files(worktree, config)
+      say "Copying files...", :cyan if options[:verbose]
+
+      copier = FileCopier.new(
+        source_path: worktree.source_path,
+        dest_path: worktree.path,
+        verbose: options[:verbose]
+      )
+
+      stats = copier.copy_from_config(config)
+
+      if stats[:copied] > 0
+        say "✓ Copied #{stats[:copied]} items", :green
+      end
+
+      if stats[:failed] > 0
+        say "✗ Failed to copy #{stats[:failed]} items", :yellow
+      end
+    end
+
+    def run_commands(worktree, config)
+      say "Running setup commands...", :cyan if options[:verbose]
+
+      runner = CommandRunner.new(
+        worktree_path: worktree.path,
+        verbose: options[:verbose]
+      )
+
+      stats = runner.run_from_config(config)
+
+      if stats[:success] > 0
+        say "✓ Executed #{stats[:success]} commands", :green
+      end
+
+      if stats[:failed] > 0
+        say "✗ #{stats[:failed]} commands failed", :yellow
+      end
+    end
+  end
+end

data/lib/workbush/command_runner.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "errors"
+
+module Workbush
+  # Handles executing post-creation commands in the new worktree
+  class CommandRunner
+    attr_reader :worktree_path, :verbose
+
+    # Initialize a new CommandRunner instance
+    #
+    # @param worktree_path [String] Path to the worktree where commands will run
+    # @param verbose [Boolean] Enable verbose output
+    def initialize(worktree_path:, verbose: false)
+      @worktree_path = File.expand_path(worktree_path)
+      @verbose = verbose
+      @success_count = 0
+      @failed_count = 0
+    end
+
+    # Run commands from configuration
+    #
+    # @param config [Config] Configuration object with commands
+    # @return [Hash] Statistics about command execution
+    def run_from_config(config)
+      commands = config.post_create_commands
+      return { success: 0, failed: 0 } if commands.empty?
+
+      log "Running post-creation commands..."
+
+      commands.each do |command|
+        run_command(command)
+      end
+
+      log_summary
+
+      {
+        success: @success_count,
+        failed: @failed_count
+      }
+    end
+
+    # Run a single command
+    #
+    # @param command [String] Command to execute
+    # @return [Boolean] True if successful
+    def run_command(command)
+      log "Executing: #{command}", :info
+
+      stdout, stderr, status = Open3.capture3(
+        command,
+        chdir: @worktree_path,
+        unsetenv_others: false
+      )
+
+      if status.success?
+        log "  ✓ Success", :success
+        log_output(stdout) if @verbose && !stdout.strip.empty?
+        @success_count += 1
+        true
+      else
+        log "  ✗ Failed (exit #{status.exitstatus})", :error
+        log_output(stderr) unless stderr.strip.empty?
+        @failed_count += 1
+        false
+      end
+    rescue StandardError => e
+      log "  ✗ Failed: #{e.message}", :error
+      @failed_count += 1
+      false
+    end
+
+    # Run commands with streaming output (for interactive commands)
+    #
+    # @param command [String] Command to execute
+    # @return [Boolean] True if successful
+    def run_command_streaming(command)
+      log "Executing: #{command}", :info
+
+      Open3.popen3(command, chdir: @worktree_path) do |_stdin, stdout, stderr, wait_thr|
+        # Stream stdout
+        Thread.new do
+          stdout.each_line { |line| puts line }
+        end
+
+        # Stream stderr
+        Thread.new do
+          stderr.each_line { |line| warn line }
+        end
+
+        status = wait_thr.value
+
+        if status.success?
+          log "  ✓ Success", :success
+          @success_count += 1
+          true
+        else
+          log "  ✗ Failed (exit #{status.exitstatus})", :error
+          @failed_count += 1
+          false
+        end
+      end
+    rescue StandardError => e
+      log "  ✗ Failed: #{e.message}", :error
+      @failed_count += 1
+      false
+    end
+
+    private
+
+    def log(message, type = :info)
+      return unless @verbose
+
+      case type
+      when :success
+        puts message
+      when :error
+        warn message
+      else
+        puts message
+      end
+    end
+
+    def log_output(output)
+      return if output.strip.empty?
+
+      output.each_line do |line|
+        puts "    #{line}"
+      end
+    end
+
+    def log_summary
+      return unless @verbose
+
+      puts
+      puts "Command summary:"
+      puts "  #{@success_count} succeeded"
+      puts "  #{@failed_count} failed" if @failed_count > 0
+    end
+  end
+end

data/lib/workbush/config.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+require_relative "errors"
+
+module Workbush
+  # Handles loading and parsing .workbush.yml configuration files
+  class Config
+    DEFAULT_CONFIG_NAME = ".workbush.yml"
+
+    attr_reader :copy_files, :copy_patterns, :copy_directories, :post_create_commands
+
+    # Initialize a new Config instance
+    #
+    # @param config_path [String, nil] Optional path to config file
+    def initialize(config_path: nil)
+      @config_path = config_path || find_config_file
+      load_config
+    end
+
+    # Check if a configuration file was found
+    #
+    # @return [Boolean]
+    def config_exists?
+      !@config_path.nil? && File.exist?(@config_path)
+    end
+
+    # Generate a default configuration template
+    #
+    # @return [String] YAML template content
+    def self.default_template
+      <<~YAML
+        # Files to copy (exact paths relative to worktree root)
+        copy_files:
+          - .env
+          - .env.local
+          - mise.local.toml
+          - config/database.yml
+
+        # Glob patterns for copying multiple files
+        copy_patterns:
+          - ".env.*"
+          - "*.lock"
+
+        # Directories to copy
+        copy_directories:
+          - node_modules
+          - vendor/bundle
+
+        # Commands to run after worktree creation
+        post_create_commands:
+          - mise trust
+          - bundle install
+          - yarn install
+      YAML
+    end
+
+    private
+
+    def load_config
+      if config_exists?
+        load_from_file
+      else
+        load_defaults
+      end
+    end
+
+    def load_from_file
+      content = File.read(@config_path)
+      erb_content = ERB.new(content).result
+      data = YAML.safe_load(erb_content, permitted_classes: [Symbol], aliases: true) || {}
+
+      @copy_files = Array(data["copy_files"])
+      @copy_patterns = Array(data["copy_patterns"])
+      @copy_directories = Array(data["copy_directories"])
+      @post_create_commands = Array(data["post_create_commands"])
+    rescue StandardError => e
+      raise ConfigError, "Failed to load config from #{@config_path}: #{e.message}"
+    end
+
+    def load_defaults
+      @copy_files = []
+      @copy_patterns = []
+      @copy_directories = []
+      @post_create_commands = []
+    end
+
+    def find_config_file
+      current_dir = Dir.pwd
+
+      # Search from current directory up to root (like git does)
+      until current_dir == "/"
+        config_file = File.join(current_dir, DEFAULT_CONFIG_NAME)
+        return config_file if File.exist?(config_file)
+
+        current_dir = File.dirname(current_dir)
+      end
+
+      nil
+    end
+  end
+end

data/lib/workbush/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Workbush
+  # Base error class for all Workbush errors
+  class Error < StandardError; end
+
+  # Raised when git repository is not found or invalid
+  class GitError < Error; end
+
+  # Raised when worktree creation fails
+  class WorktreeError < Error; end
+
+  # Raised when configuration file is invalid
+  class ConfigError < Error; end
+
+  # Raised when file operations fail
+  class FileCopyError < Error; end
+
+  # Raised when command execution fails
+  class CommandError < Error; end
+end

data/lib/workbush/file_copier.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "errors"
+
+module Workbush
+  # Handles copying files from source worktree to destination worktree
+  class FileCopier
+    attr_reader :source_path, :dest_path, :verbose
+
+    # Initialize a new FileCopier instance
+    #
+    # @param source_path [String] Source worktree path
+    # @param dest_path [String] Destination worktree path
+    # @param verbose [Boolean] Enable verbose output
+    def initialize(source_path:, dest_path:, verbose: false)
+      @source_path = File.expand_path(source_path)
+      @dest_path = File.expand_path(dest_path)
+      @verbose = verbose
+      @copied_count = 0
+      @skipped_count = 0
+      @failed_count = 0
+    end
+
+    # Copy files based on configuration
+    #
+    # @param config [Config] Configuration object with copy settings
+    # @return [Hash] Statistics about the copy operation
+    def copy_from_config(config)
+      log "Starting file copy operations..."
+
+      copy_exact_files(config.copy_files)
+      copy_matching_patterns(config.copy_patterns)
+      copy_directories(config.copy_directories)
+
+      log_summary
+
+      {
+        copied: @copied_count,
+        skipped: @skipped_count,
+        failed: @failed_count
+      }
+    end
+
+    # Copy specific files by exact path
+    #
+    # @param files [Array<String>] List of file paths relative to source
+    def copy_exact_files(files)
+      return if files.empty?
+
+      log "Copying exact files..."
+      files.each do |file|
+        source = File.join(@source_path, file)
+        dest = File.join(@dest_path, file)
+
+        copy_single_item(source, dest, file)
+      end
+    end
+
+    # Copy files matching glob patterns
+    #
+    # @param patterns [Array<String>] List of glob patterns
+    def copy_matching_patterns(patterns)
+      return if patterns.empty?
+
+      log "Copying files matching patterns..."
+      patterns.each do |pattern|
+        matches = Dir.glob(File.join(@source_path, pattern))
+
+        if matches.empty?
+          log "  No files matched pattern: #{pattern}", :skip
+          @skipped_count += 1
+          next
+        end
+
+        matches.each do |source|
+          relative_path = source.sub("#{@source_path}/", "")
+          dest = File.join(@dest_path, relative_path)
+
+          copy_single_item(source, dest, relative_path)
+        end
+      end
+    end
+
+    # Copy entire directories
+    #
+    # @param directories [Array<String>] List of directory paths
+    def copy_directories(directories)
+      return if directories.empty?
+
+      log "Copying directories..."
+      directories.each do |dir|
+        source = File.join(@source_path, dir)
+        dest = File.join(@dest_path, dir)
+
+        copy_single_item(source, dest, dir)
+      end
+    end
+
+    private
+
+    def copy_single_item(source, dest, label)
+      unless File.exist?(source)
+        log "  Skipped (not found): #{label}", :skip
+        @skipped_count += 1
+        return false
+      end
+
+      # Ensure destination directory exists
+      FileUtils.mkdir_p(File.dirname(dest))
+
+      if File.directory?(source)
+        FileUtils.cp_r(source, dest, preserve: true)
+      else
+        FileUtils.cp(source, dest, preserve: true)
+      end
+
+      log "  Copied: #{label}", :success
+      @copied_count += 1
+      true
+    rescue StandardError => e
+      log "  Failed: #{label} (#{e.message})", :error
+      @failed_count += 1
+      false
+    end
+
+    def log(message, type = :info)
+      return unless @verbose
+
+      prefix = case type
+               when :success then "✓"
+               when :skip then "○"
+               when :error then "✗"
+               else "•"
+               end
+
+      puts "#{prefix} #{message}"
+    end
+
+    def log_summary
+      return unless @verbose
+
+      puts
+      puts "Copy summary:"
+      puts "  #{@copied_count} files/directories copied"
+      puts "  #{@skipped_count} skipped" if @skipped_count > 0
+      puts "  #{@failed_count} failed" if @failed_count > 0
+    end
+  end
+end

data/lib/workbush/version.rb

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

data/lib/workbush/worktree.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require_relative "errors"
+
+module Workbush
+  # Handles git worktree operations
+  class Worktree
+    attr_reader :path, :branch
+
+    # Initialize a new Worktree instance
+    #
+    # @param path [String] Path where the worktree will be created
+    # @param branch [String, nil] Branch name to checkout
+    # @param source_path [String] Path to the source/parent worktree
+    def initialize(path:, branch: nil, source_path: Dir.pwd)
+      @path = File.expand_path(path)
+      @branch = branch
+      @source_path = source_path
+    end
+
+    # Create the worktree
+    #
+    # @param force [Boolean] Force creation even if path exists
+    # @return [String] Git command output
+    # @raise [GitError] If not in a git repository
+    # @raise [WorktreeError] If worktree creation fails
+    def create(force: false)
+      validate_git_repository!
+      validate_path!(force)
+
+      cmd = build_git_command(force)
+      execute_git_command(cmd)
+    end
+
+    # Get the parent/source worktree path
+    #
+    # @return [String]
+    def source_path
+      @source_path
+    end
+
+    # List all worktrees in the repository
+    #
+    # @return [Array<Hash>] Array of worktree information
+    def self.list
+      stdout, stderr, status = Open3.capture3("git", "worktree", "list", "--porcelain")
+
+      raise GitError, "Failed to list worktrees: #{stderr}" unless status.success?
+
+      parse_worktree_list(stdout)
+    end
+
+    # Remove a worktree
+    #
+    # @param path [String] Path to the worktree to remove
+    # @param force [Boolean] Force removal even if worktree is dirty
+    # @return [Boolean] True if successful
+    # @raise [WorktreeError] If removal fails
+    def self.remove(path, force: false)
+      cmd = ["git", "worktree", "remove", path]
+      cmd << "--force" if force
+
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        raise WorktreeError, "Failed to remove worktree: #{stderr}"
+      end
+
+      true
+    end
+
+    private
+
+    def validate_git_repository!
+      stdout, stderr, status = Open3.capture3("git", "rev-parse", "--git-dir", chdir: @source_path)
+
+      return if status.success?
+
+      raise GitError, "Not a git repository: #{@source_path}"
+    end
+
+    def validate_path!(force)
+      return unless File.exist?(@path) && !force
+
+      raise WorktreeError, "Path already exists: #{@path}. Use --force to override."
+    end
+
+    def build_git_command(force)
+      cmd = ["git", "worktree", "add"]
+      cmd << "--force" if force
+
+      if @branch
+        cmd += [@path, @branch]
+      else
+        cmd << @path
+      end
+
+      cmd
+    end
+
+    def execute_git_command(cmd)
+      stdout, stderr, status = Open3.capture3(*cmd, chdir: @source_path)
+
+      unless status.success?
+        raise WorktreeError, "Failed to create worktree: #{stderr}"
+      end
+
+      stdout
+    end
+
+    def self.parse_worktree_list(output)
+      worktrees = []
+      current = {}
+
+      output.each_line do |line|
+        line = line.strip
+        next if line.empty?
+
+        key, value = line.split(" ", 2)
+
+        case key
+        when "worktree"
+          worktrees << current unless current.empty?
+          current = { path: value }
+        when "HEAD"
+          current[:head] = value
+        when "branch"
+          current[:branch] = value
+        when "bare"
+          current[:bare] = true
+        when "detached"
+          current[:detached] = true
+        when "locked"
+          current[:locked] = value || true
+        end
+      end
+
+      worktrees << current unless current.empty?
+      worktrees
+    end
+  end
+end

data/lib/workbush.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "workbush/version"
+require_relative "workbush/errors"
+require_relative "workbush/config"
+require_relative "workbush/worktree"
+require_relative "workbush/file_copier"
+require_relative "workbush/command_runner"
+require_relative "workbush/cli"
+
+module Workbush
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: workbush
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Oğulcan Girginç
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Workbush simplifies git worktree creation by automatically copying dependencies,
+  configuration files, and running setup commands based on a simple YAML configuration.
+email:
+- ogulcan@girginc.com
+executables:
+- workbush
+extensions: []
+extra_rdoc_files: []
+files:
+- ".workbush.yml.example"
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/workbush
+- lib/workbush.rb
+- lib/workbush/cli.rb
+- lib/workbush/command_runner.rb
+- lib/workbush/config.rb
+- lib/workbush/errors.rb
+- lib/workbush/file_copier.rb
+- lib/workbush/version.rb
+- lib/workbush/worktree.rb
+homepage: https://github.com/ogirginc/workbush
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ogirginc/workbush
+  source_code_uri: https://github.com/ogirginc/workbush
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Manage git worktrees with automatic file copying and setup commands
+test_files: []