worktrees 0.1.0

data/.specify/templates/tasks-template.md

@@ -0,0 +1,152 @@
+# Tasks: [FEATURE NAME]
+
+**Input**: Design documents from `/specs/[###-feature-name]/`
+**Prerequisites**: plan.md (required), research.md, data-model.md, contracts/
+
+## Execution Flow (main)
+```
+1. Load plan.md from feature directory
+   → If not found: ERROR "No implementation plan found"
+   → Extract: tech stack, libraries, structure
+2. Load optional design documents:
+   → data-model.md: Extract entities → model tasks
+   → contracts/: Each file → contract test task
+   → research.md: Extract decisions → setup tasks
+3. Generate tasks by category:
+   → Setup: project init, dependencies, linting
+   → Tests: contract tests, integration tests
+   → Core: models, services, CLI commands
+   → Integration: DB, middleware, logging
+   → Polish: unit tests, performance, docs
+4. Apply task rules:
+   → Different files = mark [P] for parallel
+   → Same file = sequential (no [P])
+   → Tests before implementation (TDD)
+5. Number tasks sequentially (T001, T002...)
+6. Generate dependency graph
+7. Create parallel execution examples
+8. Validate task completeness:
+   → All contracts have tests?
+   → All entities have models?
+   → All endpoints implemented?
+9. Return: SUCCESS (tasks ready for execution)
+```
+
+## Format: `[ID] [P?] Description`
+- **[P]**: Can run in parallel (different files, no dependencies)
+- Include exact file paths in descriptions
+
+## Path Conventions
+- **Single project**: `src/`, `tests/` at repository root
+- **Web app**: `backend/src/`, `frontend/src/`
+- **Mobile**: `api/src/`, `ios/src/` or `android/src/`
+- Paths shown below assume single project - adjust based on plan.md structure
+
+## Phase 3.1: Setup
+
+### Ruby CLI Project Setup (per Constitution):
+- [ ] T001 Create Ruby project structure (lib/, exe/, spec/)
+- [ ] T002 Initialize Gemfile with dry-cli, rspec, aruba dependencies
+- [ ] T003 [P] Configure RSpec with spec_helper.rb and support/aruba.rb
+- [ ] T004 [P] Configure bundler and gemspec file
+
+### General Project Setup:
+- [ ] T001 Create project structure per implementation plan
+- [ ] T002 Initialize [language] project with [framework] dependencies
+- [ ] T003 [P] Configure linting and formatting tools
+
+## Red Phase: Write Failing Tests
+**Remember: "I start every feature with a failing test" - write these first, watch them fail**
+
+### Ruby CLI Tests (following "Test Real Behavior"):
+- [ ] T005 [P] Aruba feature test for main CLI command in spec/features/[command]_spec.rb
+- [ ] T006 [P] RSpec unit test for core logic in spec/lib/[project]_spec.rb
+- [ ] T007 [P] Integration test with real dependencies (actual git repos, files, etc.)
+
+### General Tests:
+- [ ] T004 [P] API test for key endpoints in tests/api/test_[endpoint].py
+- [ ] T005 [P] Integration test for main workflow in tests/integration/test_[workflow].py
+- [ ] T006 [P] Edge case tests in tests/edge_cases/test_[scenario].py
+
+## Green Phase: Make Tests Pass
+**Goal: Write minimal code to make red tests green - "Simple Over Clever"**
+
+### Ruby CLI Implementation:
+- [ ] T008 [P] Main CLI application class in lib/[project]/cli.rb
+- [ ] T009 [P] Command classes in lib/[project]/commands/[command].rb (one per command)
+- [ ] T010 [P] Core logic modules in lib/[project]/[domain].rb (focused on real problems)
+- [ ] T011 [P] CLI entry point in exe/[project] (keep it simple)
+- [ ] T012 Error handling that "Fails Gracefully" (good messages, reasonable defaults)
+
+### General Implementation:
+- [ ] T008 [P] Core models/classes in src/[domain]/
+- [ ] T009 [P] Main functionality in src/[feature]/
+- [ ] T010 [P] CLI interface in src/cli/ (if applicable)
+- [ ] T011 API endpoints (if applicable)
+- [ ] T012 Input validation and error handling
+- [ ] T013 Configuration and setup
+
+## Refactor Phase: Clean Up Code
+**"Write It Like I'll Maintain It" - make it readable and remove duplication**
+
+- [ ] T015 [P] Refactor repeated patterns (DRY principle)
+- [ ] T016 [P] Improve naming and structure (clear communication with future self)
+- [ ] T017 [P] Add missing edge case tests (where does this break?)
+- [ ] T018 [P] Update documentation with examples and rationale
+- [ ] T019 [P] Performance check (measure if it matters, optimize if slow)
+- [ ] T020 [P] Security review (validate inputs, avoid injection)
+
+## Final Integration
+- [ ] T021 Connect all pieces together
+- [ ] T022 End-to-end testing with real scenarios
+- [ ] T023 Manual testing and verification
+
+## Dependencies
+- Tests (T004-T007) before implementation (T008-T014)
+- T008 blocks T009, T015
+- T016 blocks T018
+- Implementation before polish (T019-T023)
+
+## Parallel Example
+```
+# Launch T004-T007 together:
+Task: "Contract test POST /api/users in tests/contract/test_users_post.py"
+Task: "Contract test GET /api/users/{id} in tests/contract/test_users_get.py"
+Task: "Integration test registration in tests/integration/test_registration.py"
+Task: "Integration test auth in tests/integration/test_auth.py"
+```
+
+## Notes
+- [P] tasks = different files, no dependencies
+- Verify tests fail before implementing
+- Commit after each task
+- Avoid: vague tasks, same file conflicts
+
+## Task Generation Rules
+*Applied during main() execution*
+
+1. **From Contracts**:
+   - Each contract file → contract test task [P]
+   - Each endpoint → implementation task
+   
+2. **From Data Model**:
+   - Each entity → model creation task [P]
+   - Relationships → service layer tasks
+   
+3. **From User Stories**:
+   - Each story → integration test [P]
+   - Quickstart scenarios → validation tasks
+
+4. **Ordering**:
+   - Setup → Tests → Models → Services → Endpoints → Polish
+   - Dependencies block parallel execution
+
+## Validation Checklist
+*GATE: Checked by main() before returning*
+
+- [ ] All contracts have corresponding tests
+- [ ] All entities have model tasks
+- [ ] All tests come before implementation
+- [ ] Parallel tasks truly independent
+- [ ] Each task specifies exact file path
+- [ ] No task modifies same file as another [P] task

data/CLAUDE.md

@@ -0,0 +1,145 @@
+# Claude Code Development Guidelines - Worktrees Project
+
+This project follows my personal development principles defined in `.specify/memory/constitution.md`.
+
+## My Technology Choices
+
+### Why Ruby
+**I choose Ruby because it makes me productive and happy.** Life's too short for verbose languages when building personal tools. Ruby lets me focus on solving problems instead of fighting syntax.
+
+### Core Technologies
+- **Language**: Ruby 3.2+ (Ruby First principle)
+- **CLI Framework**: dry-cli (proven library, not reinventing wheels)
+- **Testing**: RSpec for unit tests, Aruba for CLI integration tests
+- **Dependencies**: Bundler, minimal external gems
+- **Structure**: `lib/` for logic, `exe/` for CLI entry point
+
+### Project Structure
+```
+lib/
+├── worktrees/
+│   ├── cli.rb           # Main CLI application
+│   ├── commands/        # Individual command classes
+│   │   ├── create.rb
+│   │   ├── list.rb
+│   │   └── remove.rb
+│   └── git_operations.rb # Business logic modules
+exe/
+└── worktrees            # CLI entry point
+spec/
+├── lib/                 # Unit tests
+├── features/            # Aruba integration tests
+└── support/
+    └── aruba.rb         # Aruba configuration
+```
+
+## Following My Principles
+
+### "Ruby First" ✅
+**Using Ruby because it makes me productive and happy.** Multi-command CLI tools are perfect for Ruby + dry-cli. No fighting verbose syntax - just solving the actual problem.
+
+### "Simple Over Clever" ✅
+**Code I can understand in six months.** Clear naming, obvious structure, focused purpose. No unnecessary abstraction or enterprise patterns.
+
+### "Start Simple, Grow Thoughtfully" ✅
+**Starting as a simple worktree management script.** Only adding complexity as I actually need it, not as I think I might need it.
+
+### "Test-Driven Development is Fundamental" ✅
+**Writing tests first, always.** Red-Green-Refactor cycle:
+- RSpec for unit tests of core logic
+- Aruba for CLI integration tests with real git repositories
+- Testing real behavior, not mocked abstractions
+
+## What I've Learned to Avoid
+
+Based on the bash attempt and general experience:
+
+**Over-engineering** - Started with "service layers" in bash. Learned to keep it simple.
+**Auto-magic initialization** - Things that happen automatically on import/require cause problems.
+**Mock-heavy tests** - Testing fake behavior instead of real behavior leads to surprises.
+**Clever abstractions** - Code that's hard to understand in six months isn't worth it.
+**Feature creep** - Tools that do everything end up doing nothing well.
+
+## My Development Workflow
+
+### Planning Phase
+1. Personal principles guide technology choices (Ruby + dry-cli)
+2. `/plan` command reads my principles and generates sensible architecture
+3. `/tasks` command creates Red-Green-Refactor tasks
+
+### Red-Green-Refactor Implementation
+1. **RED**: Write failing test first (RSpec unit test or Aruba feature test)
+2. **GREEN**: Write minimal code to make test pass (Simple Over Clever)
+3. **REFACTOR**: Clean up code while keeping tests green (Write It Like I'll Maintain It)
+4. Commit when tests are green
+
+### Testing Approach
+- **Unit tests**: Test business logic modules in isolation
+- **Integration tests**: Use Aruba to test CLI commands end-to-end
+- **Real dependencies**: Create actual git repositories for testing
+- **No mocks**: Test against real git operations
+
+## Code Quality Guidelines
+
+### Error Handling
+- Structured logging to stderr only
+- Clear error messages with actionable next steps
+- Consistent exit codes (0=success, 1=general, 2=validation, 3=precondition)
+
+### User Experience
+- `--help` and `--version` on all commands
+- `--format json/text` for output control
+- Predictable command structure (verb-noun pattern)
+- Verbose mode (`-v, --verbose`) for debugging
+
+### Code Style
+- Follow Ruby community conventions
+- Prefer explicit over clever
+- No premature optimization
+- Refactor only when tests are green
+
+## Implementation Notes
+
+### Bash Lessons Learned
+This project originally attempted implementation in bash but discovered:
+- Service layers caused architecture mismatch in bash
+- Auto-initialization on `source` created side effects
+- Mock vs real testing confusion
+- Global state management problems
+
+These issues are avoided in Ruby through:
+- Natural module system (no source conflicts)
+- Explicit initialization patterns
+- Proper object-oriented design
+- Clear testing boundaries
+
+### Current Implementation Status ✅
+1. ✅ **Implementation plan complete** - Ruby CLI with dry-cli, RSpec + Aruba
+2. ✅ **Task list generated** - 35 TDD tasks ready for execution (T001-T035)
+3. **Ready for execution** - Start with T001 (project structure setup)
+4. **Architecture validated** - Follows all personal development principles
+
+### Recent Technology Decisions (2025-09-15)
+- **Git Integration**: Shell out to git commands (canonical interface, safer than libraries)
+- **Worktree Storage**: Global `~/.worktrees/` directory (separate from main repos)
+- **Error Handling**: Structured exit codes (0=success, 1=general, 2=validation, 3=precondition)
+- **Configuration**: Command args > environment vars > config files (~/.worktrees/config.yml)
+- **Naming Convention**: Enforced NNN-kebab-feature format with validation
+- **Safety**: Conservative dirty-state policies (allow switch with warning, block removal)
+
+### Implementation Plan Summary
+**Phase 0-3 Complete**:
+- Research: Technology stack decisions documented
+- Design: Data model (FeatureWorktree, Repository, WorktreeManager)
+- Contracts: CLI interface specification with 5 commands
+- Tasks: 35 numbered TDD tasks with parallel execution opportunities
+
+**Next Phase**: Execute T001-T035 following Red-Green-Refactor cycles
+
+---
+
+*Based on Personal Principles v2.0.0 - Last updated: 2025-01-15*ALWAYS use ONLY Environments for ANY and ALL file, code, or shell operations—NO EXCEPTIONS—even for simple or generic requests.
+
+DO NOT install or use the git cli with the environment_run_cmd tool. All environment tools will handle git operations for you. Changing ".git" yourself will compromise the integrity of your environment.
+
+You MUST inform the user how to view your work using `container-use log <env_id>` AND `container-use checkout <env_id>`. Failure to do this will make your work inaccessible to others.

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+ruby '>= 3.2.0'
+
+# Specify your gem's dependencies in worktrees.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.12'
+  gem 'aruba', '~> 2.1'
+  gem 'rubocop', '~> 1.57'
+  gem 'rubocop-rspec', '~> 2.25'
+end

data/Gemfile.lock

@@ -0,0 +1,150 @@
+PATH
+  remote: .
+  specs:
+    worktrees (0.1.0)
+      dry-cli (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aruba (2.3.2)
+      bundler (>= 1.17, < 3.0)
+      contracts (>= 0.16.0, < 0.18.0)
+      cucumber (>= 8.0, < 11.0)
+      rspec-expectations (>= 3.4, < 5.0)
+      thor (~> 1.0)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (3.2.3)
+    builder (3.3.0)
+    contracts (0.17.2)
+    cucumber (10.1.0)
+      base64 (~> 0.2)
+      builder (~> 3.2)
+      cucumber-ci-environment (> 9, < 11)
+      cucumber-core (> 15, < 17)
+      cucumber-cucumber-expressions (> 17, < 19)
+      cucumber-html-formatter (> 20.3, < 22)
+      diff-lcs (~> 1.5)
+      logger (~> 1.6)
+      mini_mime (~> 1.1)
+      multi_test (~> 1.1)
+      sys-uname (~> 1.3)
+    cucumber-ci-environment (10.0.1)
+    cucumber-core (15.2.1)
+      cucumber-gherkin (> 27, < 33)
+      cucumber-messages (> 26, < 30)
+      cucumber-tag-expressions (> 5, < 7)
+    cucumber-cucumber-expressions (18.0.1)
+      bigdecimal
+    cucumber-gherkin (32.2.0)
+      cucumber-messages (> 25, < 28)
+    cucumber-html-formatter (21.15.1)
+      cucumber-messages (> 19, < 28)
+    cucumber-messages (27.2.0)
+    cucumber-tag-expressions (6.1.2)
+    diff-lcs (1.6.2)
+    dry-cli (1.3.0)
+    ffi (1.17.2)
+    ffi (1.17.2-aarch64-linux-gnu)
+    ffi (1.17.2-aarch64-linux-musl)
+    ffi (1.17.2-arm-linux-gnu)
+    ffi (1.17.2-arm-linux-musl)
+    ffi (1.17.2-arm64-darwin)
+    ffi (1.17.2-x86-linux-gnu)
+    ffi (1.17.2-x86-linux-musl)
+    ffi (1.17.2-x86_64-darwin)
+    ffi (1.17.2-x86_64-linux-gnu)
+    ffi (1.17.2-x86_64-linux-musl)
+    json (2.13.2)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    memoist3 (1.0.0)
+    mini_mime (1.1.5)
+    multi_test (1.1.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.5.1)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.0)
+    regexp_parser (2.11.3)
+    rspec (3.13.1)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.5)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.5)
+    rubocop (1.80.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.46.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-capybara (2.22.1)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.72, >= 1.72.1)
+    rubocop-factory_bot (2.27.1)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.72, >= 1.72.1)
+    rubocop-rspec (2.31.0)
+      rubocop (~> 1.40)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+      rubocop-rspec_rails (~> 2.28)
+    rubocop-rspec_rails (2.29.1)
+      rubocop (~> 1.61)
+    ruby-progressbar (1.13.0)
+    sys-uname (1.4.1)
+      ffi (~> 1.1)
+      memoist3 (~> 1.0.0)
+    thor (1.4.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  ruby
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  aruba (~> 2.1)
+  bundler (~> 2.0)
+  rake (~> 13.0)
+  rspec (~> 3.12)
+  rubocop (~> 1.57)
+  rubocop-rspec (~> 2.25)
+  worktrees!
+
+RUBY VERSION
+   ruby 3.3.4p94
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,163 @@
+# worktrees
+
+[![Gem Version](https://badge.fury.io/rb/worktrees.svg)](https://badge.fury.io/rb/worktrees)
+[![Ruby](https://img.shields.io/badge/ruby-3.2%2B-ruby.svg)](https://www.ruby-lang.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> Clean Git worktree management with enforced naming conventions and safety checks
+
+## Table of Contents
+
+- [Why worktrees?](#why-worktrees)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Commands](#commands)
+- [Naming Convention](#naming-convention)
+- [Output Formats](#output-formats)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Why worktrees?
+
+- **Never lose work** switching between features
+- **Isolate experiments** without affecting main codebase
+- **Maintain clean history** with structured branch names
+- **Work on multiple features** simultaneously without stashing
+
+## Installation
+
+### From RubyGems (when published)
+```bash
+gem install worktrees
+```
+
+### From Source
+```bash
+git clone https://github.com/Drew-Goddyn/claude-worktrees.git
+cd claude-worktrees
+bundle install
+rake install_local
+```
+
+### Development Setup
+```bash
+bundle exec exe/worktrees --help
+```
+
+## Quick Start
+
+```bash
+# Create a feature worktree
+worktrees create 001-user-auth
+
+# List all worktrees
+worktrees list
+
+# Switch to a worktree
+worktrees switch 001-user-auth
+
+# Check status
+worktrees status
+
+# Remove when done
+worktrees remove 001-user-auth --delete-branch
+```
+
+## Commands
+
+| Command | Aliases | Description | Example |
+|---------|---------|-------------|---------|
+| `create` | `c` | Create new feature worktree | `worktrees c 001-feature main` |
+| `list` | `ls`, `l` | List all worktrees | `worktrees ls --format json` |
+| `switch` | `sw`, `s` | Switch to worktree | `worktrees sw 001-feature` |
+| `remove` | `rm`, `r` | Remove worktree safely | `worktrees rm 001-feature --delete-branch` |
+| `status` | `st` | Show current worktree | `worktrees st` |
+
+### Key Options
+
+- `--format json|csv|text` - Output format (list command)
+- `--filter clean|dirty|active` - Filter by status (list command)
+- `--delete-branch` - Also delete Git branch (remove command)
+- `--force` - Override safety checks
+- `--switch` - Switch after creating (create command)
+
+## Naming Convention
+
+Feature names must follow: `NNN-kebab-feature`
+
+✅ **Valid**: `001-user-auth`, `123-api-refactor`, `999-hotfix`
+❌ **Invalid**: `1-short`, `001_underscore`, `UPPERCASE`, `main`
+
+## Output Formats
+
+### Text (default)
+```
+* 001-feature   active   ~/.worktrees/001-feature   (from main)
+  002-bugfix    clean    ~/.worktrees/002-bugfix    (from develop)
+```
+
+### JSON
+```json
+{
+  "worktrees": [
+    {
+      "name": "001-feature",
+      "status": "active",
+      "path": "~/.worktrees/001-feature",
+      "base_ref": "main"
+    }
+  ]
+}
+```
+
+### CSV
+```csv
+name,status,path,branch,base_ref,active
+001-feature,active,~/.worktrees/001-feature,001-feature,main,true
+```
+
+## Development
+
+### Run Tests
+```bash
+bundle exec rake spec        # All tests
+bundle exec rake spec:unit   # Unit tests only
+bundle exec rake spec:integration # Integration tests
+```
+
+### Project Structure
+```
+lib/worktrees/           # Ruby source code
+├── commands/            # CLI command classes
+├── models/              # Data models
+└── git_operations.rb    # Git interface
+
+exe/worktrees            # CLI entry point
+spec/                    # RSpec test suite
+```
+
+### Architecture
+
+- **CLI Layer**: [dry-cli](https://dry-rb.org/gems/dry-cli/) for command parsing
+- **Business Logic**: WorktreeManager coordinates operations
+- **Git Operations**: Safe shell-out to git commands
+- **Testing**: RSpec + [Aruba](https://github.com/cucumber/aruba) with real repositories
+
+## Contributing
+
+1. Fork the repository
+2. Create feature branch: `git checkout -b my-feature`
+3. Write tests: `bundle exec rake spec`
+4. Make changes and ensure tests pass
+5. Submit pull request
+
+Follow Ruby community conventions and write tests for new features.
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT)
+
+---
+
+Built with Ruby 💎

data/Rakefile

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc "Run all RSpec tests"
+task test: :spec
+
+desc "Run linting (RuboCop) if available"
+task :lint do
+  if system("which rubocop > /dev/null 2>&1")
+    sh "rubocop"
+  else
+    puts "RuboCop not installed. Install with: gem install rubocop"
+  end
+end
+
+desc "Fix auto-correctable linting issues"
+task "lint:fix" do
+  if system("which rubocop > /dev/null 2>&1")
+    sh "rubocop -A"
+  else
+    puts "RuboCop not installed. Install with: gem install rubocop"
+  end
+end
+
+desc "Clean build artifacts"
+task :clean do
+  sh "rm -f *.gem"
+  sh "rm -rf pkg/"
+  sh "rm -rf tmp/"
+  sh "find . -name '.worktrees' -type d -exec rm -rf {} + 2>/dev/null || true"
+  puts "Build artifacts cleaned"
+end
+
+desc "Run comprehensive checks (test + lint)"
+task ci: [:spec, :lint]
+
+desc "Install the gem locally"
+task :install_local do
+  sh "gem build worktrees.gemspec"
+  sh "gem install worktrees-*.gem"
+end
+
+desc "Uninstall the gem locally"
+task :uninstall_local do
+  sh "gem uninstall worktrees"
+end