claude-worktree 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f961f02caebcef789ed77e043a5390b49c50397e87d21588e74e0c17417a6da
-  data.tar.gz: 91657ce429ea01a43424da72d87f71f9964a8da7e419ebb07fe59c30269c3a6d
+  metadata.gz: 1c13372671d9041cb88fbe74d783caec8d15cba40c9c0395b6ab64ef6105913c
+  data.tar.gz: dcf190dcc57792301fdddaf01ac7e880b56a14c97ee67f2095283ddc459b53dd
 SHA512:
-  metadata.gz: a0b74a2251dc6c8ff2101179ce96d87045a86198065a86a90f8c14e6da2f86a75377824a6388c68cd20ecdb2330c25dc962d35557cce8c66b318ea329a9a0aaa
-  data.tar.gz: eb1e06bd91998c652e2694a42c3ae664fd0052c90a0587a84f8fe1fc636d232dcbef6b91d55a04fd2d2efff6c5ade71cff4851479d304388c8303b918770a89e
+  metadata.gz: c1c74c92f54d58d1799bb99fa42526899dccf851c191d3db5ac193f03b49a93438f80866c28a37cd52243722863445d8a0619f81b834d376df434c3e48b722e2
+  data.tar.gz: 3c0e53ec321f5dd06aa0d79caec3f2bca13a7647e338f30c354a1a287c2712b4f83ef161f4ce37835b5b3196d547707ee68e7d5cbfeb3da10d35391a97b33036

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.1.4] - 2026-01-30
+
+### Added
+- **Permanent CD on exit**: After quitting cwt, your shell stays in the last resumed worktree directory
+- **Visible setup output**: `.cwt/setup` script now runs with visible output on first resume (not during worktree creation)
+- **Teardown support**: Optional `.cwt/teardown` script runs before worktree deletion
+- **CWT_ROOT environment variable**: Setup and teardown scripts receive `$CWT_ROOT` pointing to the repo root
+- Integration tests for setup/teardown functionality
+- Homebrew update instructions in deploy script
+
+### Changed
+- Setup now runs on first resume instead of during worktree creation
+- Setup only runs once per worktree (tracked via `.cwt_needs_setup` marker)
+
 ## [0.1.0] - 2026-01-29
 
 - Initial release

data/README.md

@@ -32,7 +32,7 @@ gem install claude-worktree
 
 Or via Homebrew Tap:
 ```bash
-brew tap bengarcia/tap
+brew tap benngarcia/tap
 brew install cwt
 ```
 
@@ -57,8 +57,10 @@ If this file exists, `cwt` will **skip the default symlinks** and execute your s
 
 ```bash
 #!/bin/bash
+# $CWT_ROOT points to your repo root
+
 # Copy .env so we can modify it safely in this session
-cp ../.env .
+cp "$CWT_ROOT/.env" .
 
 # Install dependencies freshly (cleaner than symlinking)
 npm ci
@@ -88,7 +90,7 @@ Run `cwt` in the root of any Git repository.
 
 ## 🤝 Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/bengarcia/claude-worktree.
+Bug reports and pull requests are welcome on GitHub at https://github.com/bucket-robotics/claude-worktree.
 
 ## License
 

data/lib/claude/worktree/version.rb

@@ -2,6 +2,6 @@
 
 module Claude
   module Worktree
-    VERSION = "0.1.3"
+    VERSION = "0.2.0"
   end
 end

data/lib/cwt/app.rb

@@ -2,6 +2,8 @@
 
 require "ratatui_ruby"
 require "thread"
+require_relative "repository"
+require_relative "worktree"
 require_relative "model"
 require_relative "view"
 require_relative "update"
@@ -12,26 +14,35 @@ module Cwt
     POOL_SIZE = 4
 
     def self.run
-      model = Model.new
-      
+      # Discover repository from current directory (works from worktrees too)
+      repository = Repository.discover
+      unless repository
+        puts "Error: Not in a git repository"
+        exit 1
+      end
+
+      # Change to repo root for consistent paths
+      Dir.chdir(repository.root)
+
+      model = Model.new(repository)
+
       # Initialize Thread Pool
       @worker_queue = Queue.new
       @workers = POOL_SIZE.times.map do
         Thread.new do
-          while task = @worker_queue.pop
-            # Process task
+          while (task = @worker_queue.pop)
             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] 
+                task[:result_queue] << {
+                  type: :update_status,
+                  path: task[:path],
+                  status: status,
+                  generation: task[:generation]
                 }
               end
-            rescue => e
+            rescue StandardError
               # Ignore worker errors
             end
           end
@@ -40,7 +51,7 @@ module Cwt
 
       # Initial Load
       Update.refresh_list(model)
-      
+
       # Main Event Queue
       main_queue = Queue.new
       start_background_fetch(model, main_queue)
@@ -52,7 +63,7 @@ module Cwt
           end
 
           event = tui.poll_event(timeout: 0.1)
-          
+
           # Process TUI Event
           cmd = nil
           if event.key?
@@ -62,18 +73,24 @@ module Cwt
           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
+            Update.handle(model, msg) if msg
           end
         end
       end
+
+      # After TUI exits, cd into last worktree if one was resumed
+      if model.resume_to && model.resume_to.exists?
+        Dir.chdir(model.resume_to.path)
+        # OSC 7 tells terminal emulators (Ghostty, tmux, iTerm2) the CWD for new panes
+        print "\e]7;file://localhost#{model.resume_to.path}\e\\"
+        exec ENV.fetch('SHELL', '/bin/zsh')
+      end
     end
 
     def self.handle_command(cmd, model, tui, main_queue)
@@ -88,11 +105,18 @@ module Cwt
       case cmd[:type]
       when :quit
         model.quit
-      when :create_worktree, :delete_worktree, :refresh_list
+      when :delete_worktree
+        # Suspend TUI for visible teardown output
+        RatatuiRuby.restore_terminal
+        puts "\e[H\e[2J" # Clear screen
+        result = Update.handle(model, cmd)
+        RatatuiRuby.init_terminal
+        handle_command(result, model, tui, main_queue)
+      when :create_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)
+        suspend_tui_and_run(cmd[:worktree], model, tui)
         Update.refresh_list(model)
         start_background_fetch(model, main_queue)
       end
@@ -104,20 +128,19 @@ module Cwt
       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)
+
+      # Batch fetch commit ages in background thread
       Thread.new do
-        shas = worktrees.map { |wt| wt[:sha] }.compact
-        ages = Git.get_commit_ages(shas)
-        
+        shas = worktrees.map(&:sha).compact
+        ages = Git.get_commit_ages(shas, repo_root: model.repository.root)
+
         worktrees.each do |wt|
-          if age = ages[wt[:sha]]
-            main_queue << { 
-              type: :update_commit_age, 
-              path: wt[:path], 
-              age: age, 
-              generation: current_gen 
+          if (age = ages[wt.sha])
+            main_queue << {
+              type: :update_commit_age,
+              path: wt.path,
+              age: age,
+              generation: current_gen
             }
           end
         end
@@ -125,29 +148,44 @@ module Cwt
 
       # Queue Status Checks (Worker Pool)
       worktrees.each do |wt|
-        @worker_queue << { 
-          type: :fetch_status, 
-          path: wt[:path], 
-          result_queue: main_queue, 
-          generation: current_gen 
+        @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)
+    def self.suspend_tui_and_run(worktree, model, tui)
       RatatuiRuby.restore_terminal
-      
+
       puts "\e[H\e[2J" # Clear screen
-      puts "Resuming session in #{path}..."
+
+      # Run setup if this is a new worktree
+      if worktree.needs_setup?
+        begin
+          worktree.run_setup!(visible: true)
+          worktree.mark_setup_complete!
+        rescue Interrupt
+          puts "\nSetup aborted."
+          RatatuiRuby.init_terminal
+          return
+        end
+      end
+
+      puts "Launching claude in #{worktree.path}..."
       begin
-        Dir.chdir(path) do
+        Dir.chdir(worktree.path) do
           if defined?(Bundler)
             Bundler.with_unbundled_env { system("claude") }
           else
             system("claude")
           end
         end
-      rescue => e
+        # Track last resumed worktree for exit
+        model.resume_to = worktree
+      rescue StandardError => e
         puts "Error: #{e.message}"
         print "Press any key to return..."
         STDIN.getc
@@ -156,4 +194,4 @@ module Cwt
       end
     end
   end
-end
+end

data/lib/cwt/git.rb

@@ -1,35 +1,27 @@
 # frozen_string_literal: true
 
 require 'open3'
-require 'fileutils'
 
 module Cwt
+  # Thin wrapper around git commands.
+  # Business logic lives in Repository and Worktree classes.
   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)
+    def self.get_commit_ages(shas, repo_root: nil)
       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
+      cmd = ["git"]
+      cmd += ["-C", repo_root] if repo_root
+      cmd += ["--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
+        ages[parts[0]] = parts[1] if parts.size == 2
       end
       ages
     end
@@ -39,143 +31,20 @@ module Cwt
       # --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
+    rescue StandardError
       { 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
+    def self.prune_worktrees(repo_root: nil)
+      cmd = ["git"]
+      cmd += ["-C", repo_root] if repo_root
+      cmd << "worktree" << "prune"
+      Open3.capture2(*cmd)
     end
   end
-end
+end

data/lib/cwt/model.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module Cwt
   class Model
-    attr_reader :worktrees, :selection_index, :mode, :input_buffer, :message, :running, :fetch_generation, :filter_query
+    attr_reader :repository, :selection_index, :mode, :input_buffer, :message, :running, :fetch_generation, :filter_query
+    attr_accessor :resume_to  # Worktree object or nil
 
-    def initialize
-      @worktrees = []
+    def initialize(repository)
+      @repository = repository
+      @worktrees_cache = []
       @selection_index = 0
       @mode = :normal # :normal, :creating, :filtering
       @input_buffer = String.new
@@ -11,18 +15,41 @@ module Cwt
       @message = "Welcome to CWT"
       @running = true
       @fetch_generation = 0
+      @resume_to = nil
+    end
+
+    def worktrees
+      @worktrees_cache
+    end
+
+    def refresh_worktrees!
+      @worktrees_cache = @repository.worktrees
+      clamp_selection
+      @worktrees_cache
     end
 
     def update_worktrees(list)
-      @worktrees = list
+      @worktrees_cache = list
       clamp_selection
     end
 
+    def find_worktree_by_path(path)
+      # Normalize path for comparison (handles macOS /var -> /private/var symlinks)
+      normalized = begin
+        File.realpath(path)
+      rescue Errno::ENOENT
+        File.expand_path(path)
+      end
+      @worktrees_cache.find { |wt| wt.path == normalized }
+    end
+
     def visible_worktrees
       if @filter_query.empty?
-        @worktrees
+        @worktrees_cache
       else
-        @worktrees.select { |wt| wt[:path].include?(@filter_query) || (wt[:branch] && wt[:branch].include?(@filter_query)) }
+        @worktrees_cache.select do |wt|
+          wt.path.include?(@filter_query) || (wt.branch && wt.branch.include?(@filter_query))
+        end
       end
     end
 
@@ -33,7 +60,7 @@ module Cwt
     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

data/lib/cwt/repository.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module Cwt
+  class Repository
+    WORKTREE_DIR = ".worktrees"
+    CONFIG_DIR = ".cwt"
+
+    attr_reader :root
+
+    # Find repo root from any path (including from within worktrees)
+    def self.discover(start_path = Dir.pwd)
+      Dir.chdir(start_path) do
+        stdout, status = Open3.capture2("git", "rev-parse", "--path-format=absolute", "--git-common-dir")
+        return nil unless status.success?
+
+        git_common_dir = stdout.strip
+        return nil if git_common_dir.empty?
+
+        # --git-common-dir returns /path/to/repo/.git, so strip the /.git
+        new(git_common_dir.sub(%r{/\.git$}, ''))
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def initialize(root)
+      @root = File.expand_path(root)
+    end
+
+    def worktrees_dir
+      File.join(@root, WORKTREE_DIR)
+    end
+
+    def config_dir
+      File.join(@root, CONFIG_DIR)
+    end
+
+    def setup_script_path
+      File.join(config_dir, "setup")
+    end
+
+    def teardown_script_path
+      File.join(config_dir, "teardown")
+    end
+
+    def has_setup_script?
+      File.exist?(setup_script_path) && File.executable?(setup_script_path)
+    end
+
+    def has_teardown_script?
+      File.exist?(teardown_script_path) && File.executable?(teardown_script_path)
+    end
+
+    # Returns Array<Worktree>
+    def worktrees
+      require_relative 'worktree'
+
+      stdout, status = Open3.capture2("git", "-C", @root, "worktree", "list", "--porcelain")
+      return [] unless status.success?
+
+      parse_porcelain(stdout).map do |data|
+        Worktree.new(
+          repository: self,
+          path: data[:path],
+          branch: data[:branch],
+          sha: data[:sha]
+        )
+      end
+    end
+
+    def find_worktree(name_or_path)
+      # Normalize path for comparison (handles macOS /var -> /private/var symlinks)
+      normalized_path = begin
+        File.realpath(name_or_path)
+      rescue Errno::ENOENT
+        File.expand_path(name_or_path)
+      end
+
+      worktrees.find do |wt|
+        wt.name == name_or_path || wt.path == normalized_path
+      end
+    end
+
+    # Create a new worktree with the given name
+    # Returns { success: true, worktree: Worktree } or { success: false, error: String }
+    def create_worktree(name)
+      require_relative 'worktree'
+
+      # Sanitize name
+      safe_name = name.strip.gsub(/[^a-zA-Z0-9_\-]/, '_')
+      path = File.join(worktrees_dir, safe_name)
+      absolute_path = File.join(@root, WORKTREE_DIR, safe_name)
+
+      # Ensure .worktrees exists
+      FileUtils.mkdir_p(worktrees_dir)
+
+      # Create worktree with new branch
+      cmd = ["git", "-C", @root, "worktree", "add", "-b", safe_name, path]
+      _stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        return { success: false, error: stderr }
+      end
+
+      # Create worktree object
+      worktree = Worktree.new(
+        repository: self,
+        path: absolute_path,
+        branch: safe_name,
+        sha: nil # Will be populated on next list
+      )
+
+      # Mark as needing setup
+      worktree.mark_needs_setup!
+
+      { success: true, worktree: worktree }
+    end
+
+    private
+
+    def 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
+  end
+end

data/lib/cwt/update.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "git"
-
 module Cwt
   class Update
     def self.handle(model, message)
@@ -16,26 +14,24 @@ module Cwt
         refresh_list(model)
         :start_background_fetch
       when :create_worktree
-        result = Git.add_worktree(message[:name])
+        result = model.repository.create_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] }
+          { type: :resume_worktree, worktree: result[:worktree] }
         else
           model.set_message("Error: #{result[:error]}")
           nil
         end
       when :delete_worktree
-        path = message[:path]
+        worktree = message[:worktree]
         force = message[:force] || false
-        
-        result = Git.remove_worktree(path, force: force)
-        
+
+        result = worktree.delete!(force: force)
+
         if result[:success]
           if result[:warning]
             model.set_message("Warning: #{result[:warning]}. Use 'D' to force delete.")
@@ -49,22 +45,18 @@ module Cwt
           nil
         end
       when :resume_worktree
-        { type: :suspend_and_resume, path: message[:path] }
+        { type: :suspend_and_resume, worktree: message[:worktree] }
       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
+
+        target = model.find_worktree_by_path(message[:path])
+        target.dirty = message[:status][:dirty] if target
         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
+        target = model.find_worktree_by_path(message[:path])
+        target.last_commit = message[:age] if target
         nil
       end
     end
@@ -85,10 +77,9 @@ module Cwt
           # 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 } 
+            return { type: :resume_worktree, worktree: wt }
           else
             model.set_mode(:normal)
           end
@@ -118,16 +109,15 @@ module Cwt
           model.set_mode(:filtering)
         elsif event.d?
           wt = model.selected_worktree
-          return { type: :delete_worktree, path: wt[:path], force: false } if wt
+          return { type: :delete_worktree, worktree: wt, force: false } if wt
         elsif event.D? # Shift+d
           wt = model.selected_worktree
-          return { type: :delete_worktree, path: wt[:path], force: true } if wt
+          return { type: :delete_worktree, worktree: wt, 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 }
+            return { type: :resume_worktree, worktree: wt }
           end
         elsif event.r?
           return { type: :refresh_list }
@@ -137,8 +127,7 @@ module Cwt
     end
 
     def self.refresh_list(model)
-      list = Git.list_worktrees
-      model.update_worktrees(list)
+      model.refresh_worktrees!
     end
   end
 end

data/lib/cwt/view.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../claude/worktree/version'
+
 module Cwt
   class View
     THEME = {
@@ -15,16 +17,8 @@ module Cwt
     }.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(
@@ -49,34 +43,29 @@ module Cwt
       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
+      return unless model.mode == :creating
+
+      draw_input_modal(model, tui, frame)
     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)
+      w = [area.width, width].min
+      h = [[area.height, height].min, 15].max
+      h = [h, area.height].min
+
+      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 ",
+        text: " CWT v#{Claude::Worktree::VERSION} • WORKTREE MANAGER ",
         alignment: :center,
         style: tui.style(**THEME[:header]),
         block: tui.block(
-          borders: [:bottom], 
+          borders: [:bottom],
           border_style: tui.style(**THEME[:border])
         )
       )
@@ -85,23 +74,17 @@ module Cwt
 
     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] || ""
-        
+        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: wt.name.ljust(25), style: tui.style(modifiers: [:bold])),
+          tui.text_span(content: (wt.branch || 'HEAD').ljust(25), style: tui.style(**THEME[:dim])),
           tui.text_span(content: time.rjust(15), style: tui.style(**THEME[:accent]))
         ])
       end
@@ -109,77 +92,66 @@ module Cwt
       # 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]))
+                          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]))])
+                        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
+        highlight_symbol: '▎',
         block: tui.block(
-          titles: [ { content: title_content } ],
+          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) {
+
+      add_key = lambda { |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")
+        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")
+        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")
+        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])
+      msg_style = if model.message.downcase.include?('error') || model.message.downcase.include?('warning')
+                    tui.style(fg: :red, modifiers: [:bold])
+                  else
+                    tui.style(**THEME[:accent])
+                  end
 
       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(
@@ -187,27 +159,26 @@ module Cwt
           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: ' 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
 
@@ -235,4 +206,4 @@ module Cwt
       horiz[1]
     end
   end
-end
+end

data/lib/cwt/worktree.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module Cwt
+  class Worktree
+    SETUP_MARKER = ".cwt_needs_setup"
+    DEFAULT_SYMLINKS = [".env", "node_modules"].freeze
+
+    attr_reader :repository, :path, :branch, :sha
+    attr_accessor :dirty, :last_commit
+
+    def initialize(repository:, path:, branch:, sha:)
+      @repository = repository
+      @path = File.expand_path(path)
+      @branch = branch
+      @sha = sha
+      @dirty = nil
+      @last_commit = nil
+    end
+
+    def name
+      File.basename(@path)
+    end
+
+    def exists?
+      Dir.exist?(@path)
+    end
+
+    def needs_setup?
+      File.exist?(setup_marker_path)
+    end
+
+    def mark_needs_setup!
+      FileUtils.touch(setup_marker_path)
+    end
+
+    def mark_setup_complete!
+      File.delete(setup_marker_path) if File.exist?(setup_marker_path)
+    end
+
+    # Run setup script or default symlinks
+    # visible: true shows output to user, false runs silently
+    def run_setup!(visible: true)
+      if @repository.has_setup_script?
+        run_custom_setup(visible: visible)
+      else
+        setup_default_symlinks
+      end
+    end
+
+    # Run teardown script if it exists
+    # Returns { ran: Boolean, success: Boolean }
+    def run_teardown!
+      return { ran: false } unless @repository.has_teardown_script?
+
+      puts "\e[1;36m=== Running .cwt/teardown ===\e[0m"
+      puts
+
+      success = Dir.chdir(@path) do
+        system({ "CWT_ROOT" => File.realpath(@repository.root) }, @repository.teardown_script_path)
+      end
+
+      puts
+
+      { ran: true, success: success }
+    end
+
+    # Delete this worktree and its branch
+    # force: true to force delete even with uncommitted changes
+    # Returns { success: Boolean, error: String?, warning: String? }
+    def delete!(force: false)
+      # Step 0: Run teardown script if directory exists
+      if exists?
+        result = run_teardown!
+        if result[:ran] && !result[:success] && !force
+          return { success: false, error: "Teardown script failed. Use 'D' to force delete." }
+        end
+      end
+
+      # Step 1: Cleanup symlinks/copies (Best effort)
+      cleanup_symlinks
+
+      # Step 2: Remove Worktree
+      if exists?
+        wt_cmd = ["git", "-C", @repository.root, "worktree", "remove", @path]
+        wt_cmd << "--force" if force
+
+        _stdout, stderr, status = Open3.capture3(*wt_cmd)
+
+        unless status.success?
+          return { success: false, error: stderr.strip }
+        end
+      end
+
+      # Step 3: Delete Branch
+      delete_branch(force: force)
+    end
+
+    # Fetch status (dirty flag) from git
+    def fetch_status!
+      stdout, status = Open3.capture2(
+        "git", "--no-optional-locks", "-C", @path, "status", "--porcelain"
+      )
+      @dirty = status.success? && !stdout.strip.empty?
+      @dirty
+    rescue StandardError
+      @dirty = false
+    end
+
+    # Hash representation for compatibility
+    def to_h
+      {
+        path: @path,
+        branch: @branch,
+        sha: @sha,
+        dirty: @dirty,
+        last_commit: @last_commit
+      }
+    end
+
+    private
+
+    def setup_marker_path
+      File.join(@path, SETUP_MARKER)
+    end
+
+    def run_custom_setup(visible: true)
+      if visible
+        puts "\e[1;36m=== Running .cwt/setup ===\e[0m"
+        puts
+      end
+
+      success = Dir.chdir(@path) do
+        system({ "CWT_ROOT" => File.realpath(@repository.root) }, @repository.setup_script_path)
+      end
+
+      puts if visible
+
+      unless success
+        if visible
+          puts "\e[1;33mWarning: .cwt/setup failed (exit code: #{$?.exitstatus})\e[0m"
+          print "Press Enter to continue or Ctrl+C to abort..."
+          begin
+            STDIN.gets
+          rescue Interrupt
+            raise
+          end
+        end
+      end
+
+      success
+    end
+
+    def setup_default_symlinks
+      DEFAULT_SYMLINKS.each do |file|
+        source = File.join(@repository.root, file)
+        target = File.join(@path, file)
+
+        if File.exist?(source) && !File.exist?(target)
+          FileUtils.ln_s(source, target)
+        end
+      end
+    end
+
+    def cleanup_symlinks
+      DEFAULT_SYMLINKS.each do |file|
+        target_path = File.join(@path, file)
+        File.delete(target_path) if File.exist?(target_path)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def delete_branch(force: false)
+      branch_flag = force ? "-D" : "-d"
+      _stdout, stderr, status = Open3.capture3(
+        "git", "-C", @repository.root, "branch", branch_flag, name
+      )
+
+      if status.success?
+        { success: true }
+      elsif force
+        # Force delete failed - maybe branch doesn't exist
+        if stderr.include?("not found")
+          { success: true }
+        else
+          { success: false, error: "Worktree removed, but branch delete failed: #{stderr.strip}" }
+        end
+      else
+        # Safe delete failed (unmerged commits) - worktree gone but branch kept
+        { success: true, warning: "Worktree removed, but branch kept (unmerged). Use 'D' to force." }
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude-worktree
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Ben Garcia
@@ -41,17 +41,19 @@ files:
 - lib/cwt/app.rb
 - lib/cwt/git.rb
 - lib/cwt/model.rb
+- lib/cwt/repository.rb
 - lib/cwt/update.rb
 - lib/cwt/view.rb
+- lib/cwt/worktree.rb
 - sig/claude/worktree.rbs
-homepage: https://github.com/bengarcia/claude-worktree
+homepage: https://github.com/bucket-robotics/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
+  homepage_uri: https://github.com/bucket-robotics/claude-worktree
+  source_code_uri: https://github.com/bucket-robotics/claude-worktree
+  changelog_uri: https://github.com/bucket-robotics/claude-worktree/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib