claude-worktree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11c636e0b9ef4712b640d93ea722f6ee4dc35f1b0b59798620273d6e573d2c85
+  data.tar.gz: ffb3e87aee70f3df505b5153bde9f602e4d7120071b0bbc34c520a382d4355fe
+SHA512:
+  metadata.gz: 1992b75cb17d8a3eb92eeeef6beef2fa5c40fe8fb4b44e1e32c0cdd090ea305533e4416bd433429bb10d041b743fa85a2fd79bfdf58959a697c3e6ff9d4cf660
+  data.tar.gz: 6f5e87be5321b8d4d573ca07aa5babb5012748b0708ffff838624515e4e89b00d7bc39bbbaed050397087f29c66b22a3543d0a634abf975d4ad6c434c6e45183

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-01-29
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"claude-worktree" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["hey@bengarcia.dev"](mailto:"hey@bengarcia.dev").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Ben Garcia
+
+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,91 @@
+# Claude Worktree (cwt)
+
+There are a million tools for AI coding right now. Some wrap agents in Docker containers, others proxy every shell command you type, and some try to reinvent your entire IDE.
+
+`cwt` is a simple tool built on a simple premise: **Git worktrees are the best way to isolate AI coding sessions, but they are annoying to manage manually.**
+
+The goal of this tool is to be as unimposing as possible. We don't want to change how you work, we just want to make the "setup" part faster.
+
+## How it works
+
+When you use `cwt`, you are just running a TUI (Terminal User Interface) to manage folders.
+
+1.  **It's just Git:** Under the hood, we are just creating standard Git worktrees.
+2.  **Native Environment:** When you enter a session, `cwt` suspends itself and launches a native instance of `claude` (or your preferred shell) directly in that directory.
+3.  **Zero Overhead:** We don't wrap the process. We don't intercept your commands. We don't run a background daemon. Your scripts, your aliases, and your workflow remain exactly the same.
+
+## ⚡ Features
+
+*   **Fast Management:** Create, switch, and delete worktrees instantly.
+*   **Safety Net:** cwt checks for unmerged changes before you delete a session, so you don't accidentally lose work.
+*   **Auto-Setup:** Symlinks your .env and node_modules out of the box. If you need a more advanced setup, use `.cwt/setup`
+
+## 📦 Installation
+
+```bash
+gem install claude-worktree
+```
+
+Or via Homebrew Tap:
+```bash
+brew tap bengarcia/tap
+brew install cwt
+```
+
+### The Setup Hook
+
+By default, `cwt` will:
+
+1.  Symlink `.env` from your root to the worktree.
+2.  Symlink `node_modules` from your root to the worktree.
+
+If you want to change this behavior (e.g., to run `npm ci` instead of symlinking, or to copy a different config file), simply create an executable script at `.cwt/setup`.
+
+```bash
+mkdir .cwt
+touch .cwt/setup
+chmod +x .cwt/setup
+```
+
+If this file exists, `cwt` will **skip the default symlinks** and execute your script inside the new worktree instead.
+
+**Example `.cwt/setup`:**
+
+```bash
+#!/bin/bash
+# Copy .env so we can modify it safely in this session
+cp ../.env .
+
+# Install dependencies freshly (cleaner than symlinking)
+npm ci
+
+# Print a welcome message
+echo "Ready to rock!"
+```
+
+## 🎮 Usage
+
+Run `cwt` in the root of any Git repository.
+
+| Key | Action |
+| :--- | :--- |
+| **`n`** | **New Session** (Creates worktree & launches `claude`) |
+| **`Enter`** | **Resume** (Suspends TUI, enters worktree) |
+| **`/`** | **Filter** (Search by branch or folder name) |
+| **`d`** | **Safe Delete** (Checks for unmerged changes first) |
+| **`D`** | **Force Delete** (Shift+d - The "I know what I'm doing" option) |
+| **`q`** | **Quit** |
+
+## 🏗️ Under the Hood
+
+*   Built in Ruby using `ratatui-ruby` for the UI.
+*   Uses a simple thread pool for git operations so the UI doesn't freeze.
+*   Uses `Bundler.with_unbundled_env` to ensure your session runs in a clean environment, not one polluted by this tool's dependencies.
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bengarcia/claude-worktree.
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/exe/cwt

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'cwt/app'
+
+Cwt::App.run

data/lib/claude/worktree/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Claude
+  module Worktree
+    VERSION = "0.1.0"
+  end
+end

data/lib/claude/worktree.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'worktree/version'
+
+module Claude
+  module Worktree
+    class Error < StandardError; end
+  end
+end

data/lib/cwt/app.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "ratatui_ruby"
+require "thread"
+require_relative "model"
+require_relative "view"
+require_relative "update"
+require_relative "git"
+
+module Cwt
+  class App
+    POOL_SIZE = 4
+
+    def self.run
+      model = Model.new
+      
+      # Initialize Thread Pool
+      @worker_queue = Queue.new
+      @workers = POOL_SIZE.times.map do
+        Thread.new do
+          while task = @worker_queue.pop
+            # Process task
+            begin
+              case task[:type]
+              when :fetch_status
+                status = Git.get_status(task[:path])
+                task[:result_queue] << { 
+                  type: :update_status, 
+                  path: task[:path], 
+                  status: status, 
+                  generation: task[:generation] 
+                }
+              end
+            rescue => e
+              # Ignore worker errors
+            end
+          end
+        end
+      end
+
+      # Initial Load
+      Update.refresh_list(model)
+      
+      # Main Event Queue
+      main_queue = Queue.new
+      start_background_fetch(model, main_queue)
+
+      RatatuiRuby.run do |tui|
+        while model.running
+          tui.draw do |frame|
+            View.draw(model, tui, frame)
+          end
+
+          event = tui.poll_event(timeout: 0.1)
+          
+          # Process TUI Event
+          cmd = nil
+          if event.key?
+            cmd = Update.handle(model, { type: :key_press, key: event })
+          elsif event.resize?
+            # Layout auto-handles
+          elsif event.none?
+            cmd = Update.handle(model, { type: :tick })
+          end
+          
+          handle_command(cmd, model, tui, main_queue) if cmd
+
+          # Process Background Queue
+          while !main_queue.empty?
+            msg = main_queue.pop(true) rescue nil
+            if msg
+              Update.handle(model, msg)
+            end
+          end
+        end
+      end
+    end
+
+    def self.handle_command(cmd, model, tui, main_queue)
+      return unless cmd
+
+      if cmd == :start_background_fetch
+        start_background_fetch(model, main_queue)
+        return
+      end
+
+      # Cmd is a hash
+      case cmd[:type]
+      when :quit
+        model.quit
+      when :create_worktree, :delete_worktree, :refresh_list
+        result = Update.handle(model, cmd)
+        handle_command(result, model, tui, main_queue)
+      when :resume_worktree, :suspend_and_resume
+        suspend_tui_and_run(cmd[:path], tui)
+        Update.refresh_list(model)
+        start_background_fetch(model, main_queue)
+      end
+    end
+
+    def self.start_background_fetch(model, main_queue)
+      # Increment generation to invalidate old results
+      model.increment_generation
+      current_gen = model.fetch_generation
+
+      worktrees = model.worktrees
+      
+      # Batch fetch commit ages (Fast enough to do on main thread or one-off thread? 
+      # Git.get_commit_ages is fast. Let's do it in a one-off thread to not block UI)
+      Thread.new do
+        shas = worktrees.map { |wt| wt[:sha] }.compact
+        ages = Git.get_commit_ages(shas)
+        
+        worktrees.each do |wt|
+          if age = ages[wt[:sha]]
+            main_queue << { 
+              type: :update_commit_age, 
+              path: wt[:path], 
+              age: age, 
+              generation: current_gen 
+            }
+          end
+        end
+      end
+
+      # Queue Status Checks (Worker Pool)
+      worktrees.each do |wt|
+        @worker_queue << { 
+          type: :fetch_status, 
+          path: wt[:path], 
+          result_queue: main_queue, 
+          generation: current_gen 
+        }
+      end
+    end
+
+    def self.suspend_tui_and_run(path, tui)
+      RatatuiRuby.restore_terminal
+      
+      puts "\e[H\e[2J" # Clear screen
+      puts "Resuming session in #{path}..."
+      begin
+        Dir.chdir(path) do
+          if defined?(Bundler)
+            Bundler.with_unbundled_env { system("claude") }
+          else
+            system("claude")
+          end
+        end
+      rescue => e
+        puts "Error: #{e.message}"
+        print "Press any key to return..."
+        STDIN.getc
+      ensure
+        RatatuiRuby.init_terminal
+      end
+    end
+  end
+end

data/lib/cwt/git.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module Cwt
+  class Git
+    WORKTREE_DIR = ".worktrees"
+
+    def self.list_worktrees
+      # -C . ensures we run from current dir, though we are usually there.
+      stdout, status = Open3.capture2("git", "worktree", "list", "--porcelain")
+      return [] unless status.success?
+
+      parse_porcelain(stdout)
+    end
+
+    def self.get_commit_ages(shas)
+      return {} if shas.empty?
+      
+      # Batch fetch commit times
+      # %H: full hash, %cr: relative date
+      cmd = ["git", "--no-optional-locks", "show", "-s", "--format=%H|%cr"] + shas
+      stdout, status = Open3.capture2(*cmd)
+      return {} unless status.success?
+
+      ages = {}
+      stdout.each_line do |line|
+        parts = line.strip.split('|')
+        if parts.size == 2
+          ages[parts[0]] = parts[1]
+        end
+      end
+      ages
+    end
+
+    def self.get_status(path)
+      # Check for uncommitted changes
+      # --no-optional-locks: Prevent git from writing to the index (lock contention)
+      # -C path: Run git in that directory
+      # --porcelain: stable output
+      
+      dirty_cmd = ["git", "--no-optional-locks", "-C", path, "status", "--porcelain"]
+      stdout_dirty, status_dirty = Open3.capture2(*dirty_cmd)
+      is_dirty = status_dirty.success? && !stdout_dirty.strip.empty?
+
+      { dirty: is_dirty }
+    rescue => e
+      { dirty: false }
+    end
+
+    def self.add_worktree(name)
+      # Sanitize name
+      safe_name = name.strip.gsub(/[^a-zA-Z0-9_\-]/, '_')
+      path = File.join(WORKTREE_DIR, safe_name)
+
+      # Ensure .worktrees exists
+      FileUtils.mkdir_p(WORKTREE_DIR)
+
+      # Create worktree
+      # We create a new branch with the same name as the worktree
+      cmd = ["git", "worktree", "add", "-b", safe_name, path]
+      _stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        return { success: false, error: stderr }
+      end
+
+      # Post-creation setup: Copy .env if it exists
+      setup_environment(path)
+
+      { success: true, path: path }
+    end
+
+    def self.remove_worktree(path, force: false)
+      # Step 1: Cleanup symlinks/copies (Best effort)
+      # This helps 'safe delete' succeed if only untracked files are present.
+      [".env", "node_modules"].each do |file|
+        target_path = File.join(path, file)
+        if File.exist?(target_path)
+          File.delete(target_path) rescue nil
+        end
+      end
+
+      # Step 2: Remove Worktree
+      # Only attempt if the directory actually exists.
+      # This handles the "Phantom Branch" case (worktree gone, branch remains).
+      if Dir.exist?(path)
+        wt_cmd = ["git", "--no-optional-locks", "worktree", "remove", path]
+        wt_cmd << "--force" if force
+        
+        stdout, stderr, status = Open3.capture3(*wt_cmd)
+        
+        unless status.success?
+          # If we failed to remove the worktree, we must stop unless it's a "not found" error.
+          # But "not found" should be covered by Dir.exist? check mostly.
+          # If git complains about dirty files, we stop here (unless force was used, which is handled by --force).
+          return { success: false, error: stderr.strip }
+        end
+      end
+
+      # Step 3: Delete Branch
+      # The branch name is usually the basename of the path.
+      branch_name = File.basename(path)
+      
+      branch_flag = force ? "-D" : "-d"
+      stdout_b, stderr_b, status_b = Open3.capture3("git", "branch", branch_flag, branch_name)
+
+      if status_b.success?
+        { success: true }
+      else
+        # Branch deletion failed.
+        if force
+           # Force delete failed. This is weird (maybe branch doesn't exist?).
+           # If branch doesn't exist, we can consider it success?
+           if stderr_b.include?("not found")
+             { success: true }
+           else
+             { success: false, error: "Worktree removed, but branch delete failed: #{stderr_b.strip}" }
+           end
+        else
+           # Safe delete failed (unmerged commits).
+           # This is a valid state: Worktree is gone, but branch remains to save data.
+           { success: true, warning: "Worktree removed, but branch kept (unmerged). Use 'D' to force." }
+        end
+      end
+    end
+
+    def self.prune_worktrees
+      Open3.capture2("git", "worktree", "prune")
+    end
+
+    private
+
+    def self.parse_porcelain(output)
+      worktrees = []
+      current = {}
+
+      output.each_line do |line|
+        if line.start_with?("worktree ")
+          if current.any?
+            worktrees << current
+            current = {}
+          end
+          current[:path] = line.sub("worktree ", "").strip
+        elsif line.start_with?("HEAD ")
+          current[:sha] = line.sub("HEAD ", "").strip
+        elsif line.start_with?("branch ")
+          current[:branch] = line.sub("branch ", "").strip.sub("refs/heads/", "")
+        end
+      end
+      worktrees << current if current.any?
+      worktrees
+    end
+
+    def self.setup_environment(target_path)
+      root = Dir.pwd
+      setup_script = File.join(root, ".cwt", "setup")
+
+      # 1. Custom Setup Script
+      if File.exist?(setup_script) && File.executable?(setup_script)
+        # Execute the script inside the new worktree
+        # passing the root path as an argument might be helpful, but relying on relative paths is standard.
+        Open3.capture2(setup_script, chdir: target_path)
+        return
+      end
+
+      # 2. Default Behavior: Symlink .env and node_modules
+      files_to_link = [".env", "node_modules"]
+
+      files_to_link.each do |file|
+        source = File.join(root, file)
+        target = File.join(target_path, file)
+
+        if File.exist?(source) && !File.exist?(target)
+          FileUtils.ln_s(source, target)
+        end
+      end
+    end
+  end
+end

data/lib/cwt/model.rb

@@ -0,0 +1,102 @@
+module Cwt
+  class Model
+    attr_reader :worktrees, :selection_index, :mode, :input_buffer, :message, :running, :fetch_generation, :filter_query
+
+    def initialize
+      @worktrees = []
+      @selection_index = 0
+      @mode = :normal # :normal, :creating, :filtering
+      @input_buffer = String.new
+      @filter_query = String.new
+      @message = "Welcome to CWT"
+      @running = true
+      @fetch_generation = 0
+    end
+
+    def update_worktrees(list)
+      @worktrees = list
+      clamp_selection
+    end
+
+    def visible_worktrees
+      if @filter_query.empty?
+        @worktrees
+      else
+        @worktrees.select { |wt| wt[:path].include?(@filter_query) || (wt[:branch] && wt[:branch].include?(@filter_query)) }
+      end
+    end
+
+    def increment_generation
+      @fetch_generation += 1
+    end
+
+    def move_selection(delta)
+      list = visible_worktrees
+      return if list.empty?
+      
+      new_index = @selection_index + delta
+      if new_index >= 0 && new_index < list.size
+        @selection_index = new_index
+      end
+    end
+
+    def set_mode(mode)
+      @mode = mode
+      if mode == :creating
+        @input_buffer = String.new
+        @message = "Enter session name: "
+      elsif mode == :filtering
+        @message = "Filter: "
+        # We don't clear filter query here, we assume user wants to edit it
+      else
+        @message = "Ready"
+      end
+    end
+
+    def set_filter(query)
+      @filter_query = query
+      @selection_index = 0 # Reset selection on filter change
+    end
+
+    def input_append(char)
+      if @mode == :filtering
+        @filter_query << char
+        @selection_index = 0
+      else
+        @input_buffer << char
+      end
+    end
+
+    def input_backspace
+      if @mode == :filtering
+        @filter_query.chop!
+        @selection_index = 0
+      else
+        @input_buffer.chop!
+      end
+    end
+
+    def set_message(msg)
+      @message = msg
+    end
+
+    def selected_worktree
+      visible_worktrees[@selection_index]
+    end
+
+    def quit
+      @running = false
+    end
+
+    private
+
+    def clamp_selection
+      list = visible_worktrees
+      if list.empty?
+        @selection_index = 0
+      elsif @selection_index >= list.size
+        @selection_index = list.size - 1
+      end
+    end
+  end
+end

data/lib/cwt/update.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "git"
+
+module Cwt
+  class Update
+    def self.handle(model, message)
+      case message[:type]
+      when :tick
+        nil
+      when :quit
+        model.quit
+      when :key_press
+        handle_key(model, message[:key])
+      when :refresh_list
+        refresh_list(model)
+        :start_background_fetch
+      when :create_worktree
+        result = Git.add_worktree(message[:name])
+        if result[:success]
+          model.set_message("Created worktree: #{message[:name]}")
+          refresh_list(model)
+          model.set_mode(:normal)
+          model.set_filter(String.new) # Clear filter
+          # Auto-enter the new session
+          # We return the resume command directly. 
+          # The App will execute resume, which involves suspend->run->restore->refresh->fetch
+          { type: :resume_worktree, path: result[:path] }
+        else
+          model.set_message("Error: #{result[:error]}")
+          nil
+        end
+      when :delete_worktree
+        path = message[:path]
+        force = message[:force] || false
+        
+        result = Git.remove_worktree(path, force: force)
+        
+        if result[:success]
+          if result[:warning]
+            model.set_message("Warning: #{result[:warning]}. Use 'D' to force delete.")
+          else
+            model.set_message("Deleted worktree")
+          end
+          refresh_list(model)
+          :start_background_fetch
+        else
+          model.set_message("Error deleting: #{result[:error]}. Use 'D' to force delete.")
+          nil
+        end
+      when :resume_worktree
+        { type: :suspend_and_resume, path: message[:path] }
+      when :update_status
+        return nil if message[:generation] != model.fetch_generation
+        
+        target = model.worktrees.find { |wt| wt[:path] == message[:path] }
+        if target
+          target[:dirty] = message[:status][:dirty]
+        end
+        nil
+      when :update_commit_age
+        return nil if message[:generation] != model.fetch_generation
+
+        target = model.worktrees.find { |wt| wt[:path] == message[:path] }
+        if target
+          target[:last_commit] = message[:age]
+        end
+        nil
+      end
+    end
+
+    def self.handle_key(model, event)
+      if model.mode == :creating
+        if event.enter?
+          return { type: :create_worktree, name: model.input_buffer }
+        elsif event.esc?
+          model.set_mode(:normal)
+        elsif event.backspace?
+          model.input_backspace
+        elsif event.to_s.length == 1
+          model.input_append(event.to_s)
+        end
+      elsif model.mode == :filtering
+        if event.enter?
+          # Select current item and resume
+          wt = model.selected_worktree
+          if wt
+            path = wt[:path]
+            model.set_filter(String.new) # Clear filter
+            model.set_mode(:normal) # Exit filter mode on selection
+            return { type: :resume_worktree, path: path } 
+          else
+            model.set_mode(:normal)
+          end
+        elsif event.esc?
+          model.set_filter(String.new) # Clear filter
+          model.set_mode(:normal)
+        elsif event.backspace?
+          model.input_backspace
+        elsif event.down? || event.ctrl_n?
+          model.move_selection(1)
+        elsif event.up? || event.ctrl_p?
+          model.move_selection(-1)
+        elsif event.to_s.length == 1
+          model.input_append(event.to_s)
+        end
+      else
+        # Normal Mode
+        if event.q? || event.ctrl_c?
+          return { type: :quit }
+        elsif event.j? || event.down?
+          model.move_selection(1)
+        elsif event.k? || event.up?
+          model.move_selection(-1)
+        elsif event.n?
+          model.set_mode(:creating)
+        elsif event.slash? # / key
+          model.set_mode(:filtering)
+        elsif event.d?
+          wt = model.selected_worktree
+          return { type: :delete_worktree, path: wt[:path], force: false } if wt
+        elsif event.D? # Shift+d
+          wt = model.selected_worktree
+          return { type: :delete_worktree, path: wt[:path], force: true } if wt
+        elsif event.enter?
+          wt = model.selected_worktree
+          if wt
+            path = wt[:path]
+            model.set_filter(String.new) # Clear filter on resume
+            return { type: :resume_worktree, path: path }
+          end
+        elsif event.r?
+          return { type: :refresh_list }
+        end
+      end
+      nil
+    end
+
+    def self.refresh_list(model)
+      list = Git.list_worktrees
+      model.update_worktrees(list)
+    end
+  end
+end

data/lib/cwt/view.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Cwt
+  class View
+    THEME = {
+      header: { fg: :blue, modifiers: [:bold] },
+      border: { fg: :dark_gray },
+      selection: { fg: :black, bg: :blue },
+      text: { fg: :white },
+      dim: { fg: :dark_gray },
+      accent: { fg: :cyan },
+      dirty: { fg: :yellow },
+      clean: { fg: :green },
+      modal_border: { fg: :magenta }
+    }.freeze
+
+    def self.draw(model, tui, frame)
+      # 1. Calculate App Area (Centered, Max Width/Height)
+      # Use full height but constrained width? Or constrained height too?
+      # User said "Keybindings section is so far...".
+      # If I have 3 items on a 60 row terminal, the footer is at row 60.
+      # I should shrink the height to fit content if possible.
+      
+      content_height = [model.visible_worktrees.size + 6, frame.area.height].min
+      # +6 accounts for Header(3) + Footer(3).
+      
+      # Let's enforce a minimum width/height for usability
+      app_area = centered_app_area(tui, frame.area, width: 100, height: content_height)
+
+      main_area, footer_area = tui.layout_split(
+        app_area,
+        direction: :vertical,
+        constraints: [
+          tui.constraint_fill(1),
+          tui.constraint_length(3)
+        ]
+      )
+
+      header_area, list_area = tui.layout_split(
+        main_area,
+        direction: :vertical,
+        constraints: [
+          tui.constraint_length(3),
+          tui.constraint_fill(1)
+        ]
+      )
+
+      draw_header(tui, frame, header_area)
+      draw_list(model, tui, frame, list_area)
+      draw_footer(model, tui, frame, footer_area)
+
+      if model.mode == :creating
+        draw_input_modal(model, tui, frame)
+      end
+    end
+
+    def self.centered_app_area(tui, area, width:, height:)
+       # Calculate width
+       w = [area.width, width].min
+       
+       # Calculate height (min 15 lines to avoid jarring jumps)
+       h = [[area.height, height].min, 15].max
+       h = [h, area.height].min # Ensure we don't exceed terminal
+       
+       # Center it
+       x = area.x + (area.width - w) / 2
+       y = area.y + (area.height - h) / 2
+       
+       tui.rect(x: x, y: y, width: w, height: h)
+    end
+
+    def self.draw_header(tui, frame, area)
+      # Modern, minimalist header
+      title = tui.paragraph(
+        text: " CWT • WORKTREE MANAGER ",
+        alignment: :center,
+        style: tui.style(**THEME[:header]),
+        block: tui.block(
+          borders: [:bottom], 
+          border_style: tui.style(**THEME[:border])
+        )
+      )
+      frame.render_widget(title, area)
+    end
+
+    def self.draw_list(model, tui, frame, area)
+      items = model.visible_worktrees.map do |wt|
+        name = File.basename(wt[:path])
+        branch = wt[:branch] || "HEAD"
+        
+        # Status Icons
+        # Using simple unicode that is generally supported
+        status_icon = wt[:dirty] ? "●" : " " 
+        status_style = wt[:dirty] ? tui.style(**THEME[:dirty]) : tui.style(**THEME[:clean])
+        
+        time = wt[:last_commit] || ""
+        
+        # Consistent Column Widths
+        # Name: 25, Branch: 25, Time: 15, Status: 2
+        
+        tui.text_line(spans: [
+          tui.text_span(content: " #{status_icon} ", style: status_style),
+          tui.text_span(content: name.ljust(25), style: tui.style(modifiers: [:bold])),
+          tui.text_span(content: branch.ljust(25), style: tui.style(**THEME[:dim])),
+          tui.text_span(content: time.rjust(15), style: tui.style(**THEME[:accent]))
+        ])
+      end
+
+      # Dynamic Title based on context
+      title_content = if model.mode == :filtering
+                        tui.text_line(spans: [
+                          tui.text_span(content: " FILTERING: ", style: tui.style(**THEME[:accent])),
+                          tui.text_span(content: model.filter_query, style: tui.style(fg: :white, modifiers: [:bold]))
+                        ])
+                      else
+                        tui.text_line(spans: [tui.text_span(content: " SESSIONS ", style: tui.style(**THEME[:dim]))])
+                      end
+
+      list = tui.list(
+        items: items,
+        selected_index: model.selection_index,
+        highlight_style: tui.style(**THEME[:selection]),
+        highlight_symbol: "▎", # Modern block cursor
+        block: tui.block(
+          titles: [ { content: title_content } ],
+          borders: [:all],
+          border_style: tui.style(**THEME[:border])
+        )
+      )
+      
+      frame.render_widget(list, area)
+    end
+
+    def self.draw_footer(model, tui, frame, area)
+      keys = []
+      
+      # Helper to build consistent key hints
+      add_key = ->(key, desc) {
+        keys << tui.text_span(content: " #{key} ", style: tui.style(bg: :dark_gray, fg: :white))
+        keys << tui.text_span(content: " #{desc} ", style: tui.style(**THEME[:dim]))
+      }
+
+      case model.mode
+      when :creating
+        add_key.call("Enter", "Confirm")
+        add_key.call("Esc", "Cancel")
+      when :filtering
+        add_key.call("Type", "Search")
+        add_key.call("Enter", "Select")
+        add_key.call("Esc", "Reset")
+      else
+        add_key.call("n", "New")
+        add_key.call("/", "Filter")
+        add_key.call("Enter", "Resume")
+        add_key.call("d", "Delete")
+        add_key.call("q", "Quit")
+      end
+
+      # Status Message on the right (if we calculate length, but Paragraph handles simple text)
+      # We'll put message on top line, keys on bottom line of the footer block?
+      # Or just inline them.
+      
+      # Let's do: Message .... [Keys]
+      # But Ratatui Paragraph is simple.
+      
+      # Actually, let's just render the keys. The message is overlayed or separate.
+      # The previous implementation combined them.
+      
+      # Let's put the message in the title of the footer, and keys in the body?
+      # Or Message left, keys right?
+      
+      # Simple approach: Line 1: Message (highlighted if warning). Line 2: Keys.
+      
+      msg_style = model.message.downcase.include?("error") || model.message.downcase.include?("warning") ? 
+                  tui.style(fg: :red, modifiers: [:bold]) : 
+                  tui.style(**THEME[:accent])
+
+      text = [
+        tui.text_line(spans: [tui.text_span(content: model.message, style: msg_style)]),
+        tui.text_line(spans: keys)
+      ]
+      
+      footer = tui.paragraph(
+        text: text,
+        block: tui.block(
+          borders: [:top],
+          border_style: tui.style(**THEME[:border])
+        )
+      )
+      
+      frame.render_widget(footer, area)
+    end
+
+    def self.draw_input_modal(model, tui, frame)
+      area = center_rect(tui, frame.area, 50, 3)
+      
+      # Create a "shadow" or clear background
+      frame.render_widget(tui.clear, area)
+      
+      input = tui.paragraph(
+        text: model.input_buffer,
+        style: tui.style(fg: :white),
+        block: tui.block(
+          title: " NEW SESSION ",
+          title_style: tui.style(fg: :blue, modifiers: [:bold]),
+          borders: [:all],
+          border_style: tui.style(**THEME[:modal_border])
+        )
+      )
+      
+      frame.render_widget(input, area)
+    end
+
+    def self.center_rect(tui, area, width_percent, height_len)
+      vert = tui.layout_split(
+        area,
+        direction: :vertical,
+        constraints: [
+          tui.constraint_percentage((100 - 10) / 2),
+          tui.constraint_length(height_len),
+          tui.constraint_min(0)
+        ]
+      )
+
+      horiz = tui.layout_split(
+        vert[1],
+        direction: :horizontal,
+        constraints: [
+          tui.constraint_percentage((100 - width_percent) / 2),
+          tui.constraint_percentage(width_percent),
+          tui.constraint_min(0)
+        ]
+      )
+
+      horiz[1]
+    end
+  end
+end

data/scripts/setup_demo.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'open3'
+
+# Configuration
+DEMO_DIR = "cwt_demo_repo"
+WORKTREES_DIR = ".worktrees"
+
+# Funny session names (The Prototyper's chaos)
+SESSIONS = [
+  "feature/add-lasers-to-ui",
+  "fix/undefined-is-not-a-function-again",
+  "chore/upgrade-everything-yolo",
+  "experiment/rewrite-in-assembly",
+  "refactor/rename-all-variables-to-emoji",
+  "feature/dark-mode-for-logs",
+  "bug/why-is-production-down",
+  "wip/ai-will-fix-it-eventually",
+]
+
+def run(cmd)
+  stdout, stderr, status = Open3.capture3(cmd)
+  unless status.success?
+    puts "Error running: #{cmd}"
+    puts stderr
+    exit 1
+  end
+  stdout
+end
+
+puts "🚀 Setting up CWT Demo Environment..."
+
+# 1. Create and Init Repo
+if Dir.exist?(DEMO_DIR)
+  puts "Cleaning up old demo..."
+  FileUtils.rm_rf(DEMO_DIR)
+end
+FileUtils.mkdir_p(DEMO_DIR)
+Dir.chdir(DEMO_DIR)
+
+puts "📦 Initializing git repo..."
+run "git init"
+run "git config user.email 'demo@example.com'"
+run "git config user.name 'Demo User'"
+run "touch README.md"
+run "git add README.md"
+run "git commit -m 'Initial commit'"
+
+# 2. Create Worktrees
+puts "🌳 Spawning worktrees..."
+SESSIONS.each do |session|
+  # Create branch and worktree
+  path = File.join(WORKTREES_DIR, session.gsub('/', '-'))
+  run "git worktree add -b #{session} #{path}"
+  
+  # Add some "dirty" state to random sessions
+  if rand < 0.4
+    puts "   - Making #{session} dirty..."
+    File.write(File.join(path, "dirty_file.txt"), "This is uncommitted work")
+  end
+end
+
+# 3. Create a fake .env to show off symlinking
+File.write(".env", "SECRET_KEY=12345\nAPI_HOST=localhost:3000")
+File.write("node_modules", "fake_node_modules") # Just a file for demo
+
+puts "\n✨ Demo Ready!"
+puts "To run the demo:"
+puts "  cd #{DEMO_DIR}"
+puts "  cwt"

data/sig/claude/worktree.rbs

@@ -0,0 +1,6 @@
+module Claude
+  module Worktree
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: claude-worktree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben Garcia
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ratatui_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manages git worktrees for Claude Code sessions.
+email:
+- hey@bengarcia.dev
+executables:
+- cwt
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/cwt
+- lib/claude/worktree.rb
+- lib/claude/worktree/version.rb
+- lib/cwt/app.rb
+- lib/cwt/git.rb
+- lib/cwt/model.rb
+- lib/cwt/update.rb
+- lib/cwt/view.rb
+- scripts/setup_demo.rb
+- sig/claude/worktree.rbs
+homepage: https://github.com/bengarcia/claude-worktree
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/bengarcia/claude-worktree
+  source_code_uri: https://github.com/bengarcia/claude-worktree
+  changelog_uri: https://github.com/bengarcia/claude-worktree/blob/main/CHANGELOG.md
+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.6.9
+specification_version: 4
+summary: A TUI tool to manage Git Worktrees for AI coding agents.
+test_files: []