worktrees 0.1.0

data/exe/worktrees

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add lib directory to load path
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require 'worktrees'
+
+# Handle version flag
+if ARGV.include?('--version') || ARGV.include?('-v')
+  puts "worktrees #{Worktrees::VERSION}"
+  exit(0)
+end
+
+# Handle help flag
+if ARGV.empty? || ARGV.include?('--help') || ARGV.include?('-h')
+  puts <<~HELP
+    worktrees #{Worktrees::VERSION}
+
+    USAGE:
+        worktrees [OPTIONS] <COMMAND> [ARGS]
+
+    OPTIONS:
+        -h, --help     Show help information
+        -v, --version  Show version information
+        --verbose      Enable verbose output
+
+    COMMANDS:
+        create (c)     Create a new feature worktree
+        list (ls, l)   List all worktrees for current repository
+        switch (sw, s) Switch to a different worktree
+        remove (rm, r) Remove a worktree safely
+        status (st)    Show current worktree status
+
+    Use 'worktrees <command> --help' for more information about a command.
+
+    Examples:
+        worktrees create 001-new-feature
+        worktrees create 002-bug-fix main
+        worktrees list
+        worktrees list --format json
+        worktrees switch 001-new-feature
+        worktrees remove 001-new-feature
+        worktrees status
+
+  HELP
+  exit(0)
+end
+
+# Start the CLI application
+Worktrees::App.start

data/lib/worktrees/cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module Worktrees
+  module CLI
+    extend Dry::CLI::Registry
+
+    register 'create', Worktrees::Commands::Create, aliases: ['c']
+    register 'list', Worktrees::Commands::List, aliases: ['ls', 'l']
+    register 'switch', Worktrees::Commands::Switch, aliases: ['sw', 's']
+    register 'remove', Worktrees::Commands::Remove, aliases: ['rm', 'r']
+    register 'status', Worktrees::Commands::Status, aliases: ['st']
+  end
+
+  class App
+    def self.start
+      begin
+        # Ensure we're in a git repository
+        unless Dir.exist?('.git') || system('git rev-parse --git-dir >/dev/null 2>&1')
+          warn 'ERROR: Not in a git repository'
+          warn 'Run this command from inside a git repository'
+          exit(1)
+        end
+
+        Dry::CLI.new(CLI).call
+      rescue Interrupt
+        warn "\nInterrupted"
+        exit(130)
+      rescue StandardError => e
+        warn "ERROR: #{e.message}"
+        exit(1)
+      end
+    end
+  end
+end

data/lib/worktrees/commands/create.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module Worktrees
+  module Commands
+    class Create < Dry::CLI::Command
+      desc 'Create a new feature worktree'
+
+      argument :name, required: true, desc: 'Feature name (NNN-kebab-feature format)'
+      argument :base_ref, required: false, desc: 'Base branch/commit (defaults to repository default)'
+
+      option :worktrees_root, type: :string, desc: 'Override worktrees root directory'
+      option :force, type: :boolean, default: false, desc: 'Create even if validation warnings exist'
+      option :switch, type: :boolean, default: false, desc: 'Switch to new worktree after creation'
+
+      def call(name:, base_ref: nil, **options)
+        validate_arguments(name, base_ref)
+
+        begin
+          # Create manager with options
+          config = Models::WorktreeConfig.load
+          if options[:'worktrees-root']
+            config = Models::WorktreeConfig.new(
+              worktrees_root: options[:'worktrees-root'],
+              default_base: config.default_base,
+              force_cleanup: config.force_cleanup
+            )
+          end
+
+          manager = WorktreeManager.new(nil, config)
+          create_options = options.select { |k, _| %i[force].include?(k) }
+
+          worktree = manager.create_worktree(name, base_ref, create_options)
+
+          # Display success message
+          puts "Created worktree: #{worktree.name}"
+          puts "  Path: #{worktree.path}"
+          puts "  Branch: #{worktree.branch}"
+          puts "  Base: #{worktree.base_ref}"
+          puts "  Status: #{worktree.status}"
+
+          # Switch to worktree if requested
+          if options[:switch]
+            manager.switch_to_worktree(name)
+            puts "\nSwitched to worktree: #{name}"
+          end
+
+        rescue ValidationError => e
+          warn "ERROR: Validation: #{e.message}"
+          exit(2)
+        rescue GitError => e
+          warn "ERROR: Git: #{e.message}"
+          exit(3)
+        rescue StateError => e
+          warn "ERROR: State: #{e.message}"
+          exit(3)
+        rescue StandardError => e
+          warn "ERROR: #{e.message}"
+          exit(1)
+        end
+      end
+
+      private
+
+      def validate_arguments(name, base_ref)
+        raise ValidationError, 'Name is required' if name.nil?
+        raise ValidationError, 'Name cannot be empty' if name.empty?
+
+        # Additional argument validation could go here
+      end
+    end
+  end
+end

data/lib/worktrees/commands/list.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'json'
+
+module Worktrees
+  module Commands
+    class List < Dry::CLI::Command
+      desc 'List all worktrees for current repository'
+
+      option :format, type: :string, default: 'text', values: %w[text json csv], desc: 'Output format'
+      option :status_only, type: :boolean, default: false, desc: 'Show only status information'
+      option :filter, type: :string, desc: 'Filter by status (clean, dirty, active)'
+
+      def call(**options)
+        begin
+          manager = WorktreeManager.new
+
+          # Apply status filter
+          status_filter = options[:filter] ? options[:filter].to_sym : nil
+          worktrees = manager.list_worktrees(status: status_filter)
+
+          if worktrees.empty?
+            puts 'No worktrees found'
+            return
+          end
+
+          case options[:format]
+          when 'json'
+            output_json(worktrees)
+          when 'csv'
+            output_csv(worktrees)
+          else
+            output_text(worktrees, options[:status_only])
+          end
+
+        rescue GitError => e
+          warn "ERROR: Git: #{e.message}"
+          exit(3)
+        rescue StandardError => e
+          warn "ERROR: #{e.message}"
+          exit(1)
+        end
+      end
+
+      private
+
+      def output_text(worktrees, status_only = false)
+        worktrees.each do |worktree|
+          marker = worktree.active? ? '*' : ' '
+
+          if status_only
+            puts "#{marker} #{worktree.name} #{worktree.status}"
+          else
+            puts format('%s %-20s %-8s %-40s (from %s)',
+                       marker,
+                       worktree.name,
+                       worktree.status,
+                       worktree.path,
+                       worktree.base_ref)
+          end
+        end
+      end
+
+      def output_json(worktrees)
+        data = {
+          worktrees: worktrees.map(&:to_h)
+        }
+        puts JSON.pretty_generate(data)
+      end
+
+      def output_csv(worktrees)
+        puts 'name,status,path,branch,base_ref,active'
+        worktrees.each do |worktree|
+          puts [
+            worktree.name,
+            worktree.status,
+            worktree.path,
+            worktree.branch,
+            worktree.base_ref,
+            worktree.active?
+          ].join(',')
+        end
+      end
+    end
+  end
+end

data/lib/worktrees/commands/remove.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module Worktrees
+  module Commands
+    class Remove < Dry::CLI::Command
+      desc 'Remove a worktree safely'
+
+      argument :name, required: true, desc: 'Name of worktree to remove'
+
+      option :delete_branch, type: :boolean, default: false, desc: 'Also delete the associated branch (only if fully merged)'
+      option :force_untracked, type: :boolean, default: false, desc: 'Force removal even if untracked files exist'
+      option :merge_base, type: :string, desc: 'Specify merge base for branch deletion safety check'
+      option :force, type: :boolean, default: false, desc: 'Force removal (dangerous)'
+
+      def call(name:, **options)
+        begin
+          manager = WorktreeManager.new
+
+          # Build options hash
+          remove_options = {
+            delete_branch: options[:delete_branch],
+            force_untracked: options[:force_untracked],
+            force: options[:force]
+          }
+          remove_options[:merge_base] = options[:merge_base] if options[:merge_base]
+
+          # Remove the worktree
+          result = manager.remove_worktree(name, remove_options)
+
+          if result
+            puts "Removed worktree: #{name}"
+            puts "  Path: (deleted)"
+
+            if options[:delete_branch]
+              puts "  Branch: #{name} (deleted)"
+            else
+              puts "  Branch: #{name} (kept)"
+              puts ''
+              puts 'Note: Use --delete-branch to also remove the branch if fully merged'
+            end
+          end
+
+        rescue ValidationError => e
+          warn "ERROR: Validation: #{e.message}"
+          warn 'Use \'worktrees list\' to see existing worktrees'
+          exit(2)
+        rescue StateError => e
+          warn "ERROR: Precondition: #{e.message}"
+          exit(3)
+        rescue GitError => e
+          warn "ERROR: Git: #{e.message}"
+          exit(3)
+        rescue StandardError => e
+          warn "ERROR: #{e.message}"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/worktrees/commands/status.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'json'
+
+module Worktrees
+  module Commands
+    class Status < Dry::CLI::Command
+      desc 'Show current worktree status'
+
+      option :format, type: :string, default: 'text', values: %w[text json], desc: 'Output format'
+
+      def call(**options)
+        begin
+          manager = WorktreeManager.new
+          current_worktree = manager.current_worktree
+
+          if current_worktree.nil?
+            warn 'ERROR: Not in a worktree'
+            show_repository_info(manager, options[:format])
+            exit(4)
+          end
+
+          case options[:format]
+          when 'json'
+            output_json(current_worktree, manager)
+          else
+            output_text(current_worktree, manager)
+          end
+
+        rescue GitError => e
+          warn "ERROR: Git: #{e.message}"
+          exit(3)
+        rescue StandardError => e
+          warn "ERROR: #{e.message}"
+          exit(1)
+        end
+      end
+
+      private
+
+      def output_text(worktree, manager)
+        puts "Current worktree: #{worktree.name}"
+        puts "  Path: #{worktree.path}"
+        puts "  Branch: #{worktree.branch}"
+        puts "  Base: #{worktree.base_ref}"
+
+        # Show detailed status
+        case worktree.status
+        when :dirty
+          # Could enhance to show number of modified files
+          puts "  Status: dirty (modified files)"
+        else
+          puts "  Status: #{worktree.status}"
+        end
+
+        puts ''
+        show_repository_info(manager, 'text')
+      end
+
+      def output_json(worktree, manager)
+        data = {
+          current_worktree: worktree.to_h,
+          repository: {
+            root_path: manager.repository.root_path,
+            worktrees_root: manager.config.expand_worktrees_root,
+            default_branch: manager.repository.default_branch,
+            remote_url: manager.repository.remote_url
+          }
+        }
+        puts JSON.pretty_generate(data)
+      end
+
+      def show_repository_info(manager, format)
+        if format == 'json'
+          data = {
+            repository: {
+              root_path: manager.repository.root_path,
+              worktrees_root: manager.config.expand_worktrees_root,
+              default_branch: manager.repository.default_branch,
+              remote_url: manager.repository.remote_url
+            }
+          }
+          puts JSON.pretty_generate(data)
+        else
+          puts "Repository: #{manager.repository.root_path}"
+          puts "Worktrees root: #{manager.config.expand_worktrees_root}"
+          if manager.repository.remote_url
+            puts "Remote: #{manager.repository.remote_url}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worktrees/commands/switch.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module Worktrees
+  module Commands
+    class Switch < Dry::CLI::Command
+      desc 'Switch to a different worktree'
+
+      argument :name, required: true, desc: 'Name of worktree to switch to'
+
+      option :force, type: :boolean, default: false, desc: 'Switch even if current worktree is dirty'
+
+      def call(name:, **options)
+        begin
+          manager = WorktreeManager.new
+
+          # Check if target worktree exists
+          target_worktree = manager.find_worktree(name)
+          unless target_worktree
+            raise ValidationError, "Worktree '#{name}' not found"
+          end
+
+          # Check current state for warnings/blocking
+          current = manager.current_worktree
+          if current && current.dirty? && !options[:force]
+            # Per requirements: allow switch with warning (not blocking)
+            warn "Warning: Previous worktree '#{current.name}' has uncommitted changes"
+          end
+
+          # Perform the switch
+          switched_worktree = manager.switch_to_worktree(name)
+
+          puts "Switched to worktree: #{switched_worktree.name}"
+          puts "  Path: #{switched_worktree.path}"
+          puts "  Branch: #{switched_worktree.branch}"
+          puts "  Status: #{switched_worktree.status}"
+
+          # Show previous worktree warning if applicable
+          if current && current.dirty?
+            puts "\nWarning: Previous worktree '#{current.name}' has uncommitted changes"
+          end
+
+        rescue ValidationError => e
+          warn "ERROR: Validation: #{e.message}"
+          exit(2)
+        rescue StateError => e
+          warn "ERROR: State: #{e.message}"
+          exit(3)
+        rescue StandardError => e
+          warn "ERROR: #{e.message}"
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/worktrees/git_operations.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Worktrees
+  module GitOperations
+    class << self
+      def create_worktree(path, branch, base_ref)
+        # Check if branch already exists
+        if branch_exists?(branch)
+          # Checkout existing branch
+          system('git', 'worktree', 'add', path, branch)
+        else
+          # Create new branch from base_ref
+          system('git', 'worktree', 'add', '-b', branch, path, base_ref)
+        end
+      end
+
+      def list_worktrees
+        begin
+          output = `git worktree list --porcelain`
+          raise GitError, "Failed to list worktrees: git command failed" unless $?.success?
+
+          parse_worktree_list(output)
+        rescue StandardError => e
+          raise GitError, "Failed to list worktrees: #{e.message}"
+        end
+      end
+
+      def remove_worktree(path, force: false)
+        args = ['git', 'worktree', 'remove']
+        args << '--force' if force
+        args << path
+
+        system(*args)
+      end
+
+      def branch_exists?(branch_name)
+        system('git', 'show-ref', '--verify', '--quiet', "refs/heads/#{branch_name}")
+      end
+
+      def current_branch
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      def is_clean?(worktree_path)
+        system('git', 'diff-index', '--quiet', 'HEAD', chdir: worktree_path)
+      end
+
+      def has_unpushed_commits?(branch_name)
+        begin
+          output = `git rev-list @{u}..HEAD`
+          $?.success? && !output.strip.empty?
+        rescue StandardError
+          # No upstream branch or other error - consider as no unpushed commits
+          false
+        end
+      end
+
+      def fetch_ref(ref)
+        system('git', 'fetch', 'origin', ref)
+      end
+
+      def delete_branch(branch_name, force: false)
+        flag = force ? '-D' : '-d'
+        system('git', 'branch', flag, branch_name)
+      end
+
+      def is_merged?(branch_name, base_branch = 'main')
+        # Check if all commits in branch_name are reachable from base_branch
+        system('git', 'merge-base', '--is-ancestor', branch_name, base_branch)
+      end
+
+      private
+
+      def parse_worktree_list(output)
+        worktrees = []
+        current_worktree = {}
+
+        output.each_line do |line|
+          line.strip!
+          next if line.empty?
+
+          case line
+          when /^worktree (.+)$/
+            # Save previous worktree if exists
+            worktrees << current_worktree unless current_worktree.empty?
+            current_worktree = { path: $1 }
+          when /^HEAD (.+)$/
+            current_worktree[:commit] = $1
+          when /^branch (.+)$/
+            current_worktree[:branch] = $1.sub('refs/heads/', '')
+          when /^detached$/
+            current_worktree[:detached] = true
+          when /^bare$/
+            current_worktree[:bare] = true
+          end
+        end
+
+        # Add the last worktree
+        worktrees << current_worktree unless current_worktree.empty?
+
+        # Filter out bare and main repository worktrees
+        worktrees.reject { |wt| wt[:bare] || wt[:path]&.end_with?('/.git') }
+      end
+    end
+  end
+end

data/lib/worktrees/models/feature_worktree.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Worktrees
+  module Models
+    class FeatureWorktree
+      NAME_PATTERN = /^[0-9]{3}-[a-z0-9-]{1,40}$/.freeze
+      RESERVED_NAMES = %w[main master].freeze
+
+      attr_reader :name, :path, :branch, :base_ref, :status, :created_at, :repository_path
+
+      def initialize(name:, path:, branch:, base_ref:, status:, created_at:, repository_path:)
+        @name = name
+        @path = path
+        @branch = branch
+        @base_ref = base_ref
+        @status = status
+        @created_at = created_at
+        @repository_path = repository_path
+
+        validate!
+      end
+
+      def valid?
+        return false unless @name.is_a?(String) && @name.match?(NAME_PATTERN)
+
+        feature_part = @name.split('-', 2)[1]
+        return false if feature_part.nil?
+        return false if RESERVED_NAMES.include?(feature_part.downcase)
+
+        return false if @path.nil? || @path.empty?
+        return false if @branch.nil? || @branch.empty?
+        return false if @base_ref.nil? || @base_ref.empty?
+
+        true
+      end
+
+      def active?
+        @status == :active
+      end
+
+      def dirty?
+        @status == :dirty
+      end
+
+      def to_h
+        {
+          name: @name,
+          path: @path,
+          branch: @branch,
+          base_ref: @base_ref,
+          status: @status,
+          created_at: @created_at,
+          repository_path: @repository_path,
+          active: active?
+        }
+      end
+
+      def self.validate_name(name)
+        return false unless name.is_a?(String)
+        return false unless name.match?(NAME_PATTERN)
+
+        # Extract feature part after NNN-
+        feature_part = name.split('-', 2)[1]
+        return false if feature_part.nil?
+
+        # Check for reserved names
+        !RESERVED_NAMES.include?(feature_part.downcase)
+      end
+
+      private
+
+      def validate!
+        # First check basic format
+        unless @name.is_a?(String) && @name.match?(NAME_PATTERN)
+          raise ValidationError, "Invalid name format '#{@name}'. Names must match pattern: NNN-kebab-feature"
+        end
+
+        # Check for reserved names
+        feature_part = @name.split('-', 2)[1]
+        if feature_part && RESERVED_NAMES.include?(feature_part.downcase)
+          raise ValidationError, "Reserved name '#{feature_part}' not allowed in worktree names"
+        end
+
+        raise ValidationError, 'Path cannot be empty' if @path.nil? || @path.empty?
+        raise ValidationError, 'Branch cannot be empty' if @branch.nil? || @branch.empty?
+        raise ValidationError, 'Base reference cannot be empty' if @base_ref.nil? || @base_ref.empty?
+      end
+    end
+  end
+end