Enhance worktree commands with flexible path and naming support

- Extend try . to support custom names and different repo paths (try . [name], try ./path [name])
- Add explicit try worktree dir [name] command for non-shell usage
- Improve git worktree detection to work with specified repository paths
- Update documentation with new command variants and usage examples
- Add comprehensive test coverage for worktree functionality
- Refactor shell emission helpers for better organization

Author: tobi

AGENTS.md

@@ -9,6 +9,8 @@
 ## CLI Interface
 - `try init [PATH]`: Emits a tiny shell wrapper function for your shell. PATH sets the root (absolute path recommended). The function evals the printed, shell-neutral script to `cd` into selections.
 - `try cd [QUERY]`: Launches the interactive selector. If `QUERY` looks like a Git URL, it performs a clone workflow instead. Prints a shell script to stdout; use via the installed function.
+- `try . [name]`: Shorthand to create a date-prefixed directory and, if inside a Git repo, add a detached worktree. Optional `name` overrides the basename.
+- `try worktree dir [name]`: Same as above but explicit CLI, useful without the shell wrapper.
 - `try clone <git-uri> [name]`: Clones into the root. Default name is `YYYY-MM-DD-user-repo` (strips `.git`). Optional `name` overrides.
 - Flags: `--path PATH` (for `cd`/`clone`) overrides the root for that call; `--help` prints global help.
 - Environment: `TRY_PATH` sets the default root when not using `--path`.

README.md

@@ -104,14 +104,16 @@ Notes:
 try                                          # Browse all experiments
 try redis                                    # Jump to redis experiment or create new
 try new api                                  # Start with "2025-08-17-new-api"
-try .                                         # Create a dated worktree dir for current repo
+try . [name]                                   # Create a dated worktree dir for current repo
+try ./path/to/repo [name]                      # Use another repo as the worktree source
+try worktree dir [name]                        # Same as above, explicit CLI form
 try clone https://github.com/user/repo.git  # Clone repo into date-prefixed directory
 try https://github.com/user/repo.git        # Shorthand for clone (same as above)
 try --help                                   # See all options
 ```
 
-Notes on `try .`:
-- Uses the real path's basename for the name, prefixed with today’s date.
+Notes on worktrees (`try .` / `try worktree dir`):
+- With a custom [name], uses that; otherwise uses cwd’s basename. Both are prefixed with today’s date.
 - Inside a Git repo: adds a detached HEAD git worktree to the created directory.
 - Outside a repo: simply creates the directory and changes into it.
 

tests/test_worktree_cmd.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'open3'
+require 'tmpdir'
+
+class TestWorktreeCmd < Test::Unit::TestCase
+  def run_cmd(*args)
+    cmd = [RbConfig.ruby, File.expand_path('../try.rb', __dir__), *args]
+    Open3.capture3(*cmd)
+  end
+
+  def test_worktree_dir_with_name
+    Dir.mktmpdir do |tries|
+      Dir.mktmpdir do |repo|
+        FileUtils.mkdir_p(File.join(repo, '.git')) # simulate repo
+        stdout, _stderr, _status = Open3.capture3(RbConfig.ruby, File.expand_path('../try.rb', __dir__), 'worktree', 'dir', 'xyz', '--path', tries, chdir: repo)
+        assert_match(/mkdir -p '\S+\d{4}-\d{2}-\d{2}-xyz'/, stdout)
+        assert_match(/worktree add --detach '\S+\d{4}-\d{2}-\d{2}-xyz'/, stdout)
+        assert_match(/cd '\S+\d{4}-\d{2}-\d{2}-xyz'/, stdout)
+      end
+    end
+  end
+end

tests/test_worktree_dot.rb

@@ -14,6 +14,7 @@ def test_try_dot_emits_worktree_step_and_uses_cwd_name
       # Create a fake project directory name
       proj = File.join(dir, 'myproj')
       FileUtils.mkdir_p(proj)
+      FileUtils.mkdir_p(File.join(proj, '.git')) # simulate git repo
       tries = Dir.mktmpdir
 
       stdout, _stderr, _status = run_cmd(proj, 'cd', '.', '--path', tries)
@@ -24,4 +25,28 @@ def test_try_dot_emits_worktree_step_and_uses_cwd_name
       assert_match(/\d{4}-\d{2}-\d{2}-#{Regexp.escape(base)}/, stdout)
     end
   end
+
+  def test_try_dot_with_name_overrides_basename
+    Dir.mktmpdir do |dir|
+      proj = File.join(dir, 'myproj')
+      FileUtils.mkdir_p(proj)
+      FileUtils.mkdir_p(File.join(proj, '.git')) # simulate git repo
+      tries = Dir.mktmpdir
+
+      stdout, _stderr, _status = run_cmd(proj, 'cd', '.', 'custom-name', '--path', tries)
+      assert_match(/worktree add --detach '\S+custom-name'/, stdout)
+      assert_match(/\d{4}-\d{2}-\d{2}-custom-name/, stdout)
+    end
+  end
+
+  def test_try_dot_without_git_skips_worktree
+    Dir.mktmpdir do |dir|
+      proj = File.join(dir, 'plain')
+      FileUtils.mkdir_p(proj)
+      tries = Dir.mktmpdir
+      stdout, _stderr, _status = run_cmd(proj, 'cd', '.', '--path', tries)
+      refute_match(/worktree add --detach/, stdout)
+      assert_match(/mkdir -p '\S+\d{4}-\d{2}-\d{2}-plain'/, stdout)
+    end
+  end
 end

try.rb

@@ -34,7 +34,7 @@ def self.puts(text = "", io: STDERR)
   end
 
   def self.flush(io: STDERR)
-    # Always finalize the current line into the buffer
+    # Always fine into the buffer
     unless @@current_line.empty?
       @@buffer << @@current_line
       @@current_line = ""
@@ -872,27 +872,36 @@ def cmd_init!(args, tries_path)
   end
 
   def cmd_cd!(args, tries_path, and_type, and_exit, and_keys, and_confirm)
-    search_term = args.join(' ')
-
-    # Shorthand: try . → derive name from cwd and add git worktree if available
-    if search_term.strip == '.'
-      base = begin
-        File.basename(File.realpath(Dir.pwd))
-      rescue
-        File.basename(Dir.pwd)
+    # Support: try . [name] and try ./path [name]
+    if args.first && args.first.start_with?('.')
+      path_arg = args.shift
+      custom = args.join(' ')
+      repo_dir = File.expand_path(path_arg)
+      base = if custom && !custom.strip.empty?
+        custom.gsub(/\s+/, '-')
+      else
+        File.basename(repo_dir)
       end
       date_prefix = Time.now.strftime("%Y-%m-%d")
       dir_name = "#{date_prefix}-#{base}"
       full_path = File.join(tries_path, dir_name)
-      return [
+      tasks = [
         { type: 'target', path: full_path },
-        { type: 'mkdir' },
-        { type: 'git-worktree' },
+        { type: 'mkdir' }
+      ]
+      # Only add worktree when a .git directory exists at that path
+      if File.directory?(File.join(repo_dir, '.git'))
+        tasks << { type: 'git-worktree', repo: repo_dir }
+      end
+      tasks += [
         { type: 'touch' },
         { type: 'cd' }
       ]
+      return tasks
     end
 
+    search_term = args.join(' ')
+
     # Git URL shorthand → clone workflow
     if is_git_uri?(search_term.split.first)
       git_uri, custom_name = search_term.split(/\s+/, 2)
@@ -933,7 +942,44 @@ def cmd_cd!(args, tries_path, and_type, and_exit, and_keys, and_confirm)
     tasks
   end
 
+  # --- Shell emission helpers (moved out of UI) ---
+  def join_commands(parts)
+    parts.join(" \\\n+  && ")
+  end
 
+  def emit_script(parts)
+    puts join_commands(parts)
+  end
+
+  # tasks: [{type: 'target', path: '/abs/dir'}, {type: 'mkdir'|'touch'|'cd'|'git-clone'|'git-worktree', ...}]
+  def emit_tasks_script(tasks)
+    target = tasks.find { |t| t[:type] == 'target' }
+    full_path = target && target[:path]
+    raise 'emit_tasks_script requires a target path' unless full_path
+
+    parts = []
+    q = "'" + full_path.gsub("'", %q('"'"'')) + "'"
+    tasks.each do |t|
+      case t[:type]
+      when 'mkdir'
+        parts << "mkdir -p #{q}"
+      when 'git-clone'
+        parts << "git clone '#{t[:uri]}' #{q}"
+      when 'git-worktree'
+        if t[:repo]
+          r = "'" + t[:repo].gsub("'", %q('"'"'')) + "'"
+          parts << "/usr/bin/env sh -c 'if git -C " + r + " rev-parse --is-inside-work-tree >/dev/null 2>&1; then repo=\$(git -C " + r + " rev-parse --show-toplevel); git -C \"$repo\" worktree add --detach #{q} >/dev/null 2>&1 || true; fi; exit 0'"
+        else
+          parts << "/usr/bin/env sh -c 'if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then repo=\$(git rev-parse --show-toplevel); git -C \"$repo\" worktree add --detach #{q} >/dev/null 2>&1 || true; fi; exit 0'"
+        end
+      when 'touch'
+        parts << "touch #{q}"
+      when 'cd'
+        parts << "cd #{q}"
+      end
+    end
+    emit_script(parts)
+  end
 
   # shell detection for init wrapper
   def fish?
@@ -951,6 +997,37 @@ def fish?
   when 'init'
     cmd_init!(ARGV, tries_path)
     exit 0
+  when 'worktree'
+    sub = ARGV.shift
+    case sub
+    when 'dir'
+      # try worktree dir [name]
+      custom = ARGV.join(' ')
+      base = if custom && !custom.strip.empty?
+        custom.gsub(/\s+/, '-')
+      else
+        begin
+          File.basename(File.realpath(Dir.pwd))
+        rescue
+          File.basename(Dir.pwd)
+        end
+      end
+      date_prefix = Time.now.strftime("%Y-%m-%d")
+      dir_name = "#{date_prefix}-#{base}"
+      full_path = File.join(tries_path, dir_name)
+      tasks = [
+        { type: 'target', path: full_path },
+        { type: 'mkdir' },
+        { type: 'git-worktree' },
+        { type: 'touch' },
+        { type: 'cd' }
+      ]
+      emit_tasks_script(tasks)
+      exit 0
+    else
+      warn "Unknown worktree subcommand: #{sub.inspect}"
+      exit 2
+    end
   when 'cd'
     tasks = cmd_cd!(ARGV, tries_path, and_type, and_exit, and_keys, and_confirm)
     emit_tasks_script(tasks) if tasks
@@ -961,25 +1038,4 @@ def fish?
     exit 2
   end
 
-
-  full_path = tasks.shift[:path] or raise "emit_tasks_script requires a target path"
-
-  parts = []
-  q = "'" + full_path.gsub("'", %q('"'"'')) + "'" # POSIX-safe single-quote; also works in fish
-  tasks.each do |t|
-    case t[:type]
-    when 'mkdir'
-      parts << "mkdir -p #{q}"
-    when 'git-clone'
-      parts << "git clone '#{t[:uri]}' #{q}"
-    when 'git-worktree'
-      parts << "/usr/bin/env sh -c 'if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then repo=\$(git rev-parse --show-toplevel); git -C \"$repo\" worktree add --detach #{q} >/dev/null 2>&1 || true; fi; exit 0'"
-    when 'touch'
-      parts << "touch #{q}"
-    when 'cd'
-      parts << "cd #{q}"
-    end
-  end
-  puts parts.join(" \\\n+  && ")
-
 end