feat: add symlink hook

README.md

@@ -39,6 +39,11 @@ hooks:
       from: ".env" # Allowed even if gitignored. 'from' is always relative to the MAIN worktree
       to: ".env" # Destination is relative to the NEW worktree
 
+    # Share directories between the MAIN and NEW worktree
+    - type: symlink
+      from: ".bin"
+      to: ".bin"
+
     # Prefer explicit, single-step setup commands
     - type: command
       command: "npm ci" # Example for Node.js (replace with your build/deps tool)
@@ -202,6 +207,11 @@ hooks:
       from: ".claude" # Copy AI context file (gitignored)
       to: ".claude"
 
+    # Share directories between the main and new worktree
+    - type: symlink
+      from: ".bin"
+      to: ".bin"
+
     # Execute commands in the new worktree
     - type: command
       command: "npm install"
@@ -246,6 +256,24 @@ hooks:
 This behavior applies regardless of where you run `wtp add` from (main worktree
 or any other worktree).
 
+### Symlink Hooks: Shared Assets
+
+Symlink hooks are useful for sharing large or mutable directories from the main
+worktree (e.g. `.bin`, `.cache`, `node_modules`).
+
+- `from`: path is resolved relative to the main worktree (or absolute).
+- `to`: path is resolved relative to the newly created worktree (or absolute).
+
+Example:
+
+```yaml
+hooks:
+  post_create:
+    - type: symlink
+      from: ".bin"
+      to: ".bin"
+```
+
 ## Shell Integration
 
 ### Tab Completion Setup

cmd/wtp/init.go

@@ -93,6 +93,11 @@ hooks:
     # - type: copy
     #   from: .cursor/    # Cursor IDE settings
     #   to: .cursor/
+
+    # Share directories with symlinks:
+    # - type: symlink
+    #   from: .bin        # Shared tool cache
+    #   to: .bin
 
     # Run setup commands:
     # - type: command

docs/architecture.md

@@ -113,6 +113,9 @@ hooks:
     - type: command
       command: "npm install"
       work_dir: "."
+    - type: symlink
+      from: ".bin"
+      to: ".bin"
 ```
 
 ## Hook System
@@ -122,6 +125,7 @@ hooks:
 Post-create hooks support:
 - File copying (for .env files, etc.)
 - Command execution
+- Symlink creation (for shared binaries, caches, etc.)
 
 This covers 90% of use cases without over-engineering.
 

internal/config/config.go

@@ -28,7 +28,7 @@ type Hooks struct {
 
 // Hook represents a single hook configuration
 type Hook struct {
-	Type    string            `yaml:"type"` // "copy" or "command"
+	Type    string            `yaml:"type"` // "copy", "command", or "symlink"
 	From    string            `yaml:"from,omitempty"`
 	To      string            `yaml:"to,omitempty"`
 	Command string            `yaml:"command,omitempty"`
@@ -46,7 +46,9 @@ const (
 	// HookTypeCopy identifies a hook that copies files.
 	HookTypeCopy = "copy"
 	// HookTypeCommand identifies a hook that executes a command.
-	HookTypeCommand       = "command"
+	HookTypeCommand = "command"
+	// HookTypeSymlink identifies a hook that creates symlinks.
+	HookTypeSymlink       = "symlink"
 	configFilePermissions = 0o600
 )
 
@@ -151,8 +153,15 @@ func (h *Hook) Validate() error {
 		if h.From != "" || h.To != "" {
 			return fmt.Errorf("command hook should not have 'from' or 'to' fields")
 		}
+	case HookTypeSymlink:
+		if h.From == "" || h.To == "" {
+			return fmt.Errorf("symlink hook requires both 'from' and 'to' fields")
+		}
+		if h.Command != "" {
+			return fmt.Errorf("symlink hook should not have 'command' field")
+		}
 	default:
-		return fmt.Errorf("invalid hook type '%s', must be 'copy' or 'command'", h.Type)
+		return fmt.Errorf("invalid hook type '%s', must be 'copy', 'command', or 'symlink'", h.Type)
 	}
 
 	return nil

internal/config/config_test.go

@@ -37,6 +37,9 @@ hooks:
       to: ".env"
     - type: command
       command: "echo test"
+    - type: symlink
+      from: ".bin"
+      to: ".bin"
 `
 
 	err := os.WriteFile(configPath, []byte(configContent), 0644)
@@ -57,8 +60,8 @@ hooks:
 		t.Errorf("Expected base_dir '../my-worktrees', got %s", config.Defaults.BaseDir)
 	}
 
-	if len(config.Hooks.PostCreate) != 2 {
-		t.Errorf("Expected 2 hooks, got %d", len(config.Hooks.PostCreate))
+	if len(config.Hooks.PostCreate) != 3 {
+		t.Errorf("Expected 3 hooks, got %d", len(config.Hooks.PostCreate))
 	}
 
 	if config.Hooks.PostCreate[0].Type != HookTypeCopy {
@@ -68,6 +71,10 @@ hooks:
 	if config.Hooks.PostCreate[1].Type != HookTypeCommand {
 		t.Errorf("Expected second hook type 'command', got %s", config.Hooks.PostCreate[1].Type)
 	}
+
+	if config.Hooks.PostCreate[2].Type != HookTypeSymlink {
+		t.Errorf("Expected third hook type 'symlink', got %s", config.Hooks.PostCreate[2].Type)
+	}
 }
 
 func TestLoadConfig_InvalidYAML(t *testing.T) {
@@ -259,6 +266,15 @@ func TestHookValidate(t *testing.T) {
 			},
 			expectError: false,
 		},
+		{
+			name: "valid symlink hook",
+			hook: Hook{
+				Type: HookTypeSymlink,
+				From: ".bin",
+				To:   ".bin",
+			},
+			expectError: false,
+		},
 		{
 			name: "copy hook missing from",
 			hook: Hook{
@@ -292,6 +308,32 @@ func TestHookValidate(t *testing.T) {
 			},
 			expectError: true,
 		},
+		{
+			name: "symlink hook missing from",
+			hook: Hook{
+				Type: HookTypeSymlink,
+				To:   ".bin",
+			},
+			expectError: true,
+		},
+		{
+			name: "symlink hook missing to",
+			hook: Hook{
+				Type: HookTypeSymlink,
+				From: ".bin",
+			},
+			expectError: true,
+		},
+		{
+			name: "symlink hook with command field",
+			hook: Hook{
+				Type:    HookTypeSymlink,
+				From:    ".bin",
+				To:      ".bin",
+				Command: "echo", // Should not have command
+			},
+			expectError: true,
+		},
 		{
 			name: "command hook with from/to fields",
 			hook: Hook{

internal/hooks/executor.go

@@ -66,6 +66,8 @@ func (e *Executor) executeHookWithWriter(w io.Writer, hook *config.Hook, worktre
 		return e.executeCopyHookWithWriter(w, hook, worktreePath)
 	case config.HookTypeCommand:
 		return e.executeCommandHookWithWriter(w, hook, worktreePath)
+	case config.HookTypeSymlink:
+		return e.executeSymlinkHookWithWriter(w, hook, worktreePath)
 	default:
 		return fmt.Errorf("unknown hook type: %s", hook.Type)
 	}
@@ -122,6 +124,69 @@ func (e *Executor) executeCopyHookWithWriter(w io.Writer, hook *config.Hook, wor
 	return e.copyFile(srcPath, dstPath)
 }
 
+// executeSymlinkHookWithWriter executes a symlink hook with output directed to writer
+func (e *Executor) executeSymlinkHookWithWriter(w io.Writer, hook *config.Hook, worktreePath string) error {
+	// Resolve source path (relative to repo root)
+	srcPath := hook.From
+	if !filepath.IsAbs(srcPath) {
+		srcPath = filepath.Join(e.repoRoot, srcPath)
+	}
+	srcPath = filepath.Clean(srcPath)
+	if !filepath.IsAbs(hook.From) {
+		if err := ensureWithinBase(e.repoRoot, srcPath); err != nil {
+			return err
+		}
+	}
+
+	// Resolve destination path (relative to worktree)
+	dstPath := hook.To
+	if !filepath.IsAbs(dstPath) {
+		dstPath = filepath.Join(worktreePath, dstPath)
+	}
+	dstPath = filepath.Clean(dstPath)
+	if !filepath.IsAbs(hook.To) {
+		if err := ensureWithinBase(worktreePath, dstPath); err != nil {
+			return err
+		}
+	}
+
+	// Check if source exists
+	if _, err := os.Stat(srcPath); err != nil {
+		return fmt.Errorf("source path does not exist: %s", srcPath)
+	}
+
+	// Create destination directory if needed
+	dstDir := filepath.Dir(dstPath)
+	if err := os.MkdirAll(dstDir, directoryPermissions); err != nil {
+		return fmt.Errorf("failed to create destination directory: %w", err)
+	}
+
+	// Prevent clobbering existing paths
+	if _, err := os.Lstat(dstPath); err == nil {
+		return fmt.Errorf("destination path already exists: %s", dstPath)
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("failed to inspect destination path: %w", err)
+	}
+
+	// Log the symlink operation to writer
+	relSrc, _ := filepath.Rel(e.repoRoot, srcPath)
+	relDst, _ := filepath.Rel(worktreePath, dstPath)
+	if _, err := fmt.Fprintf(w, "  Symlinking: %s → %s\n", relSrc, relDst); err != nil {
+		return err
+	}
+
+	linkTarget := srcPath
+	if relTarget, err := filepath.Rel(dstDir, srcPath); err == nil {
+		linkTarget = relTarget
+	}
+
+	if err := os.Symlink(linkTarget, dstPath); err != nil {
+		return fmt.Errorf("failed to create symlink: %w", err)
+	}
+
+	return nil
+}
+
 func ensureWithinBase(base, target string) error {
 	rel, err := filepath.Rel(base, target)
 	if err != nil {

internal/hooks/executor_test.go

@@ -36,6 +36,21 @@ func TestExecutePostCreateHooks_NoHooks(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func requireSymlinkSupport(t *testing.T) {
+	t.Helper()
+	if runtime.GOOS != "windows" {
+		return
+	}
+
+	tempDir := t.TempDir()
+	srcPath := filepath.Join(tempDir, "src")
+	dstPath := filepath.Join(tempDir, "dst")
+	require.NoError(t, os.WriteFile(srcPath, []byte("ok"), 0644))
+	if err := os.Symlink(srcPath, dstPath); err != nil {
+		t.Skipf("symlink not supported on this system: %v", err)
+	}
+}
+
 func TestExecutePostCreateHooks_InvalidHookType(t *testing.T) {
 	cfg := &config.Config{
 		Hooks: config.Hooks{
@@ -100,6 +115,58 @@ func TestExecutePostCreateHooks_CopyFile(t *testing.T) {
 	assert.Contains(t, output, "✓ Hook 1 completed")
 }
 
+func TestExecutePostCreateHooks_Symlink(t *testing.T) {
+	requireSymlinkSupport(t)
+
+	tempDir := t.TempDir()
+	repoRoot := filepath.Join(tempDir, "repo")
+	worktreeDir := filepath.Join(tempDir, "worktree")
+
+	err := os.MkdirAll(repoRoot, directoryPermissions)
+	require.NoError(t, err)
+	err = os.MkdirAll(worktreeDir, directoryPermissions)
+	require.NoError(t, err)
+
+	srcDir := filepath.Join(repoRoot, ".bin")
+	require.NoError(t, os.MkdirAll(srcDir, directoryPermissions))
+	require.NoError(t, os.WriteFile(filepath.Join(srcDir, "tool"), []byte("bin"), 0644))
+
+	cfg := &config.Config{
+		Hooks: config.Hooks{
+			PostCreate: []config.Hook{
+				{
+					Type: config.HookTypeSymlink,
+					From: ".bin",
+					To:   ".bin",
+				},
+			},
+		},
+	}
+
+	executor := NewExecutor(cfg, repoRoot)
+	var buf bytes.Buffer
+	err = executor.ExecutePostCreateHooks(&buf, worktreeDir)
+	assert.NoError(t, err)
+
+	dstPath := filepath.Join(worktreeDir, ".bin")
+	info, err := os.Lstat(dstPath)
+	require.NoError(t, err)
+	assert.NotZero(t, info.Mode()&os.ModeSymlink)
+
+	linkTarget, err := os.Readlink(dstPath)
+	require.NoError(t, err)
+
+	resolvedTarget := linkTarget
+	if !filepath.IsAbs(resolvedTarget) {
+		resolvedTarget = filepath.Join(filepath.Dir(dstPath), resolvedTarget)
+	}
+	assert.Equal(t, filepath.Clean(srcDir), filepath.Clean(resolvedTarget))
+
+	output := buf.String()
+	assert.Contains(t, output, "Symlinking: .bin → .bin")
+	assert.Contains(t, output, "✓ Hook 1 completed")
+}
+
 func TestExecutePostCreateHooks_Command(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("Skipping command test on Windows")