fix: remove hardcoded branch names from push/pull operations

- Remove hardcoded "main" branch from git push and pull commands
- Let Git automatically detect and use current branch
- Add comprehensive tests for different branch names (main, master, develop)
- Fixes GitHub issue #14 where operations failed on repos using "master"

.github/dependabot.yml

@@ -0,0 +1,17 @@
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/optimizing-pr-creation-version-updates#setting-up-a-cooldown-period-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    # https://docs.github.com/en/code-security/dependabot/working-with-dependabot/dependabot-options-reference#groups--
+    groups:
+      actions:
+        # Combine all images of last week
+        patterns: ["*"]
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: weekly

.github/workflows/ci.yml

@@ -9,6 +9,9 @@ on:
 permissions:
   contents: read
 
+env:
+  GO_VERSION: '1.24'
+
 jobs:
   test:
     runs-on: ubuntu-latest
@@ -19,10 +22,10 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: ${{ env.GO_VERSION }}
 
       - name: Cache Go modules
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@@ -44,9 +47,9 @@ jobs:
         run: go test -v -race -coverprofile=coverage.out ./...
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v5
         with:
-          file: ./coverage.out
+          files: ./coverage.out
 
   lint:
     runs-on: ubuntu-latest
@@ -57,10 +60,10 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: ${{ env.GO_VERSION }}
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v8
         with:
           version: latest
 
@@ -74,7 +77,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: ${{ env.GO_VERSION }}
 
       - name: Build
         run: go build -v ./...

.gitignore

@@ -44,3 +44,5 @@ desktop.ini
 
 # GoReleaser artifacts
 goreleaser/
+*.md
+!/README.md

README.md

@@ -2,11 +2,17 @@
 
 **Git-native dotfiles management that doesn't suck.**
 
-Move your dotfiles to `~/.config/lnk`, symlink them back, and use Git like normal. Supports both common configurations and host-specific setups.
+Lnk makes managing your dotfiles straightforward, no tedious setups, no complex configurations. Just tell Lnk what files you want tracked, and it'll automatically move them into a tidy Git repository under `~/.config/lnk`. It then creates clean, portable symlinks back to their original locations. Easy.
+
+Why bother with Lnk instead of plain old Git or other dotfile managers? Unlike traditional methods, Lnk automates the boring parts: safely relocating files, handling host-specific setups, bulk operations for multiple files, recursive directory processing, and even running your custom bootstrap scripts automatically. This means fewer manual steps and less chance of accidentally overwriting something important.
+
+With Lnk, your dotfiles setup stays organized and effortlessly portable, letting you spend more time doing real work, not wrestling with configuration files.
 
 ```bash
-lnk init
+lnk init -r git@github.com:user/dotfiles.git    # Clones & runs bootstrap automatically
-lnk add ~/.vimrc ~/.bashrc              # Common config
+lnk add ~/.vimrc ~/.bashrc ~/.gitconfig         # Multiple files at once
+lnk add --recursive ~/.config/nvim              # Process directory contents
+lnk add --dry-run ~/.tmux.conf                  # Preview changes first
 lnk add --host work ~/.ssh/config               # Host-specific config
 lnk push "setup"
 ```
@@ -20,7 +26,6 @@ curl -sSL https://raw.githubusercontent.com/yarlson/lnk/main/install.sh | bash
 
 ```bash
 # Homebrew (macOS/Linux)
-brew tap yarlson/lnk
 brew install lnk
 ```
 
@@ -43,19 +48,35 @@ git clone https://github.com/yarlson/lnk.git && cd lnk && go build . && sudo mv
 # Fresh start
 lnk init
 
-# With existing repo
+# With existing repo (runs bootstrap automatically)
 lnk init -r git@github.com:user/dotfiles.git
+
+# Skip automatic bootstrap
+lnk init -r git@github.com:user/dotfiles.git --no-bootstrap
+
+# Force initialization (WARNING: overwrites existing managed files)
+lnk init -r git@github.com:user/dotfiles.git --force
+
+# Run bootstrap script manually
+lnk bootstrap
 ```
 
 ### Daily workflow
 
 ```bash
-# Add files/directories (common config)
+# Add multiple files at once (common config)
-lnk add ~/.vimrc ~/.config/nvim ~/.gitconfig
+lnk add ~/.vimrc ~/.bashrc ~/.gitconfig ~/.tmux.conf
 
-# Add host-specific files
+# Add directory contents individually
-lnk add --host laptop ~/.ssh/config
+lnk add --recursive ~/.config/nvim ~/.config/zsh
-lnk add --host work ~/.gitconfig
+
+# Preview changes before applying
+lnk add --dry-run ~/.config/git/config
+lnk add --dry-run --recursive ~/.config/kitty
+
+# Add host-specific files (supports bulk operations)
+lnk add --host laptop ~/.ssh/config ~/.aws/credentials
+lnk add --host work ~/.gitconfig ~/.ssh/config
 
 # List managed files
 lnk list                    # Common config only
@@ -85,6 +106,71 @@ After:  ~/.ssh/config -> ~/.config/lnk/laptop.lnk/.ssh/config (symlink)
 
 Your files live in `~/.config/lnk` (a Git repo). Common files go in the root, host-specific files go in `<host>.lnk/` subdirectories. Lnk creates symlinks back to original locations. Edit files normally, use Git normally.
 
+## Safety Features
+
+Lnk includes built-in safety checks to prevent accidental data loss:
+
+### Data Loss Prevention
+
+```bash
+# This will be blocked if you already have managed files
+lnk init -r git@github.com:user/dotfiles.git
+# ❌ Directory ~/.config/lnk already contains managed files
+#    💡 Use 'lnk pull' to update from remote instead of 'lnk init -r'
+
+# Use pull instead to safely update
+lnk pull
+
+# Or force if you understand the risks (shows warning only when needed)
+lnk init -r git@github.com:user/dotfiles.git --force
+# ⚠️  Using --force flag: This will overwrite existing managed files
+#    💡 Only use this if you understand the risks
+```
+
+### Smart Warnings
+
+- **Contextual alerts**: Warnings only appear when there are actually managed files to overwrite
+- **Clear guidance**: Error messages suggest the correct command to use
+- **Force override**: Advanced users can bypass safety checks when needed
+
+## Bootstrap Support
+
+Lnk automatically runs bootstrap scripts when cloning dotfiles repositories, making it easy to set up your development environment. Just add a `bootstrap.sh` file to your dotfiles repo.
+
+### Examples
+
+**Simple bootstrap script:**
+
+```bash
+#!/bin/bash
+# bootstrap.sh
+echo "Setting up development environment..."
+
+# Install Homebrew (macOS)
+if ! command -v brew &> /dev/null; then
+    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+fi
+
+# Install packages
+brew install git vim tmux
+
+echo "✅ Setup complete!"
+```
+
+**Usage:**
+
+```bash
+# Automatic bootstrap on clone
+lnk init -r git@github.com:you/dotfiles.git
+# → Clones repo and runs bootstrap script automatically
+
+# Skip bootstrap if needed
+lnk init -r git@github.com:you/dotfiles.git --no-bootstrap
+
+# Run bootstrap manually later
+lnk bootstrap
+```
+
 ## Multihost Support
 
 Lnk supports both **common configurations** (shared across all machines) and **host-specific configurations** (unique per machine).
@@ -111,12 +197,19 @@ Lnk supports both **common configurations** (shared across all machines) and **h
 ### Usage Patterns
 
 ```bash
-# Common config (shared everywhere)
+# Common config (shared everywhere) - supports multiple files
-lnk add ~/.vimrc ~/.bashrc ~/.gitconfig
+lnk add ~/.vimrc ~/.bashrc ~/.gitconfig ~/.tmux.conf
 
-# Host-specific config (unique per machine)
+# Process directory contents individually
-lnk add --host $(hostname) ~/.ssh/config
+lnk add --recursive ~/.config/nvim ~/.config/zsh
-lnk add --host work ~/.gitconfig
+
+# Preview operations before making changes
+lnk add --dry-run ~/.config/alacritty/alacritty.yml
+lnk add --dry-run --recursive ~/.config/i3
+
+# Host-specific config (unique per machine) - supports bulk operations
+lnk add --host $(hostname) ~/.ssh/config ~/.aws/credentials
+lnk add --host work ~/.gitconfig ~/.npmrc
 
 # List configurations
 lnk list                    # Common only
@@ -132,23 +225,35 @@ lnk pull --host work        # Work-specific config
 
 You could `git init ~/.config/lnk` and manually symlink everything. Lnk just automates the tedious parts:
 
-- Moving files safely
+- Moving files safely (with atomic operations)
 - Creating relative symlinks
-- Handling conflicts
+- Handling conflicts and rollback
 - Tracking what's managed
+- Processing multiple files efficiently
+- Recursive directory traversal
+- Preview mode for safety
 
 ## Examples
 
 ### First time setup
 
 ```bash
+# Clone dotfiles and run bootstrap automatically
 lnk init -r git@github.com:you/dotfiles.git
+# → Downloads dependencies, installs packages, configures environment
 
-# Add common config (shared across all machines)
+# Add common config (shared across all machines) - multiple files at once
-lnk add ~/.bashrc ~/.vimrc ~/.gitconfig
+lnk add ~/.bashrc ~/.vimrc ~/.gitconfig ~/.tmux.conf
 
-# Add host-specific config
+# Add configuration directories individually
-lnk add --host $(hostname) ~/.ssh/config ~/.tmux.conf
+lnk add --recursive ~/.config/nvim ~/.config/zsh
+
+# Preview before adding sensitive files
+lnk add --dry-run ~/.ssh/id_rsa.pub
+lnk add ~/.ssh/id_rsa.pub  # Add after verification
+
+# Add host-specific config (supports bulk operations)
+lnk add --host $(hostname) ~/.ssh/config ~/.aws/credentials
 
 lnk push "initial setup"
 ```
@@ -156,13 +261,18 @@ lnk push "initial setup"
 ### On a new machine
 
 ```bash
+# Bootstrap runs automatically
 lnk init -r git@github.com:you/dotfiles.git
+# → Sets up environment, installs dependencies
 
 # Pull common config
 lnk pull
 
 # Pull host-specific config (if it exists)
 lnk pull --host $(hostname)
+
+# Or run bootstrap manually if needed
+lnk bootstrap
 ```
 
 ### Daily edits
@@ -179,15 +289,16 @@ lnk push "new plugins"          # commit & push
 ### Multi-machine workflow
 
 ```bash
-# On your laptop
+# On your laptop - use bulk operations for efficiency
-lnk add --host laptop ~/.ssh/config
+lnk add --host laptop ~/.ssh/config ~/.aws/credentials ~/.npmrc
-lnk add ~/.vimrc                # Common config
+lnk add ~/.vimrc ~/.bashrc ~/.gitconfig    # Common config (multiple files)
-lnk push "laptop ssh config"
+lnk push "laptop configuration"
 
 # On your work machine
 lnk pull                                   # Get common config
-lnk add --host work ~/.gitconfig
+lnk add --host work ~/.gitconfig ~/.ssh/config
-lnk push "work git config"
+lnk add --recursive ~/.config/work-tools  # Work-specific tools
+lnk push "work configuration"
 
 # Back on laptop
 lnk pull                                   # Get updates (work config won't affect laptop)
@@ -195,19 +306,41 @@ lnk pull                        # Get updates (work config won't affect laptop)
 
 ## Commands
 
-- `lnk init [-r remote]` - Create repo
+- `lnk init [-r remote] [--no-bootstrap] [--force]` - Create repo (runs bootstrap automatically)
-- `lnk add [--host HOST] <files>` - Move files to repo, create symlinks
+- `lnk add [--host HOST] [--recursive] [--dry-run] <files>...` - Move files to repo, create symlinks
 - `lnk rm [--host HOST] <files>` - Move files back, remove symlinks
 - `lnk list [--host HOST] [--all]` - List files managed by lnk
 - `lnk status` - Git status + sync info
 - `lnk push [msg]` - Stage all, commit, push
 - `lnk pull [--host HOST]` - Pull + restore missing symlinks
+- `lnk bootstrap` - Run bootstrap script manually
 
 ### Command Options
 
 - `--host HOST` - Manage files for specific host (default: common configuration)
+- `--recursive, -r` - Add directory contents individually instead of the directory as a whole
+- `--dry-run, -n` - Show what would be added without making changes
 - `--all` - Show all configurations (common + all hosts) when listing
 - `-r, --remote URL` - Clone from remote URL when initializing
+- `--no-bootstrap` - Skip automatic execution of bootstrap script after cloning
+- `--force` - Force initialization even if directory contains managed files (WARNING: overwrites existing content)
+
+### Add Command Examples
+
+```bash
+# Multiple files at once
+lnk add ~/.bashrc ~/.vimrc ~/.gitconfig
+
+# Recursive directory processing
+lnk add --recursive ~/.config/nvim
+
+# Preview changes first
+lnk add --dry-run ~/.ssh/config
+lnk add --dry-run --recursive ~/.config/kitty
+
+# Host-specific bulk operations
+lnk add --host work ~/.gitconfig ~/.ssh/config ~/.npmrc
+```
 
 ## Technical bits
 
@@ -215,13 +348,18 @@ lnk pull                        # Get updates (work config won't affect laptop)
 - **Relative symlinks** (portable)
 - **XDG compliant** (`~/.config/lnk`)
 - **Multihost support** (common + host-specific configs)
+- **Bootstrap support** (automatic environment setup)
+- **Bulk operations** (multiple files, atomic transactions)
+- **Recursive processing** (directory contents individually)
+- **Preview mode** (dry-run for safety)
+- **Data loss prevention** (safety checks with contextual warnings)
 - **Git-native** (standard Git repo, no special formats)
 
 ## Alternatives
 
 | Tool    | Complexity | Why choose it                                                                             |
-| ------- | ---------- | -------------------------------------------- |
+| ------- | ---------- | ----------------------------------------------------------------------------------------- |
-| **lnk** | Minimal    | Just works, no config, Git-native, multihost |
+| **lnk** | Minimal    | Just works, no config, Git-native, multihost, bootstrap, bulk ops, dry-run, safety checks |
 | chezmoi | High       | Templates, encryption, cross-platform                                                     |
 | yadm    | Medium     | Git power user, encryption                                                                |
 | dotbot  | Low        | YAML config, basic features                                                               |

RELEASE.md

@@ -1,190 +0,0 @@
-# Release Process
-
-This document describes how to create releases for the lnk project using GoReleaser.
-
-## Prerequisites
-
-- Push access to the main repository
-- Git tags pushed to GitHub trigger releases automatically
-- GoReleaser is configured in `.goreleaser.yml`
-- GitHub Actions will handle the release process
-- Access to the [homebrew-lnk](https://github.com/yarlson/homebrew-lnk) tap repository
-- **Personal Access Token** set up as `HOMEBREW_TAP_TOKEN` secret (see Setup section)
-
-## Setup (One-time)
-
-### GitHub Personal Access Token
-
-For GoReleaser to update the Homebrew formula, you need a Personal Access Token:
-
-1. Go to GitHub Settings → Developer settings → Personal access tokens → Tokens (classic)
-2. Click "Generate new token" → "Generate new token (classic)"
-3. Name: "GoReleaser Homebrew Access"
-4. Scopes: Select `repo` (Full control of private repositories)
-5. Generate and copy the token
-6. In your `yarlson/lnk` repository:
-   - Go to Settings → Secrets and variables → Actions
-   - Add new repository secret: `HOMEBREW_TAP_TOKEN`
-   - Paste the token as the value
-
-This allows GoReleaser to automatically update the Homebrew formula in [homebrew-lnk](https://github.com/yarlson/homebrew-lnk).
-
-## Creating a Release
-
-### 1. Ensure everything is ready
-
-```bash
-# Run all quality checks
-make check
-
-# Test GoReleaser configuration
-make goreleaser-check
-
-# Test build process
-make goreleaser-snapshot
-```
-
-### 2. Create and push a version tag
-
-```bash
-# Create a new tag (replace x.y.z with actual version)
-git tag -a v1.0.0 -m "Release v1.0.0"
-
-# Push the tag to trigger the release
-git push origin v1.0.0
-```
-
-### 3. Monitor the release
-
-- GitHub Actions will automatically build and release when the tag is pushed
-- Check the [Actions tab](https://github.com/yarlson/lnk/actions) for build status
-- The release will appear in [GitHub Releases](https://github.com/yarlson/lnk/releases)
-- The Homebrew formula will be automatically updated in [homebrew-lnk](https://github.com/yarlson/homebrew-lnk)
-
-## What GoReleaser Does
-
-1. **Builds binaries** for multiple platforms:
-
-   - Linux (amd64, arm64)
-   - macOS (amd64, arm64)
-   - Windows (amd64)
-
-2. **Creates archives** with consistent naming:
-
-   - `lnk_Linux_x86_64.tar.gz`
-   - `lnk_Darwin_arm64.tar.gz`
-   - etc.
-
-3. **Generates checksums** for verification
-
-4. **Creates GitHub release** with:
-
-   - Automatic changelog from conventional commits
-   - Installation instructions
-   - Download links for all platforms
-
-5. **Updates Homebrew formula** automatically in the [homebrew-lnk](https://github.com/yarlson/homebrew-lnk) tap
-
-## Manual Release (if needed)
-
-If you need to create a release manually:
-
-```bash
-# Export GitHub token
-export GITHUB_TOKEN="your_token_here"
-
-# Create release (requires a git tag)
-goreleaser release --clean
-```
-
-## Testing Releases Locally
-
-```bash
-# Test the build process without releasing
-make goreleaser-snapshot
-
-# Built artifacts will be in dist/
-ls -la dist/
-
-# Test a binary
-./dist/lnk_<platform>/lnk --version
-```
-
-## Installation Methods
-
-After a release is published, users can install lnk using multiple methods:
-
-### 1. Shell Script (Recommended)
-
-```bash
-curl -sSL https://raw.githubusercontent.com/yarlson/lnk/main/install.sh | bash
-```
-
-### 2. Homebrew (macOS/Linux)
-
-```bash
-brew tap yarlson/lnk
-brew install lnk
-```
-
-### 3. Manual Download
-
-```bash
-# Download from GitHub releases
-wget https://github.com/yarlson/lnk/releases/latest/download/lnk_Linux_x86_64.tar.gz
-tar -xzf lnk_Linux_x86_64.tar.gz
-sudo mv lnk /usr/local/bin/
-```
-
-## Version Numbering
-
-We use [Semantic Versioning](https://semver.org/):
-
-- `v1.0.0` - Major release (breaking changes)
-- `v1.1.0` - Minor release (new features, backward compatible)
-- `v1.1.1` - Patch release (bug fixes)
-
-## Changelog
-
-GoReleaser automatically generates changelogs from git commits using conventional commit format:
-
-- `feat:` - New features
-- `fix:` - Bug fixes
-- `docs:` - Documentation changes (excluded from changelog)
-- `test:` - Test changes (excluded from changelog)
-- `ci:` - CI changes (excluded from changelog)
-
-## Homebrew Tap
-
-The Homebrew formula is automatically maintained in the [homebrew-lnk](https://github.com/yarlson/homebrew-lnk) repository. When a new release is created:
-
-1. GoReleaser automatically creates/updates the formula
-2. The formula is committed to the tap repository
-3. Users can immediately install the new version via `brew install yarlson/lnk/lnk`
-
-## Troubleshooting
-
-### Release failed to create
-
-1. Check that the tag follows the format `vX.Y.Z`
-2. Ensure GitHub Actions has proper permissions
-3. Check the Actions log for detailed error messages
-
-### Missing binaries in release
-
-1. Verify GoReleaser configuration: `make goreleaser-check`
-2. Test build locally: `make goreleaser-snapshot`
-3. Check the build matrix in `.goreleaser.yml`
-
-### Changelog is empty
-
-1. Ensure commits follow conventional commit format
-2. Check that there are commits since the last tag
-3. Verify changelog configuration in `.goreleaser.yml`
-
-### Homebrew formula not updated
-
-1. Check that the GITHUB_TOKEN has access to the homebrew-lnk repository
-2. Verify the repository name and owner in `.goreleaser.yml`
-3. Check the release workflow logs for Homebrew-related errors
-4. Ensure the homebrew-lnk repository exists and is accessible

cmd/add.go

@@ -9,22 +9,122 @@ import (
 
 func newAddCmd() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:           "add <file>",
+		Use:   "add <file>...",
-		Short:         "✨ Add a file to lnk management",
+		Short: "✨ Add files to lnk management",
-		Long:          "Moves a file to the lnk repository and creates a symlink in its place.",
+		Long: `Moves files to the lnk repository and creates symlinks in their place. Supports multiple files.
-		Args:          cobra.ExactArgs(1),
+
+Examples:
+  lnk add ~/.bashrc ~/.vimrc          # Add multiple files at once
+  lnk add --recursive ~/.config/nvim  # Add directory contents individually  
+  lnk add --dry-run ~/.gitconfig      # Preview what would be added
+  lnk add --host work ~/.ssh/config   # Add host-specific configuration
+
+The --recursive flag processes directory contents individually instead of treating 
+the directory as a single unit. This is useful for configuration directories where
+you want each file managed separately.
+
+The --dry-run flag shows you exactly what files would be added without making any
+changes to your system - perfect for verification before bulk operations.`,
+		Args:          cobra.MinimumNArgs(1),
 		SilenceUsage:  true,
 		SilenceErrors: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			filePath := args[0]
 			host, _ := cmd.Flags().GetString("host")
-
+			recursive, _ := cmd.Flags().GetBool("recursive")
+			dryRun, _ := cmd.Flags().GetBool("dry-run")
 			lnk := core.NewLnk(core.WithHost(host))
 
-			if err := lnk.Add(filePath); err != nil {
+			// Handle dry-run mode
+			if dryRun {
+				files, err := lnk.PreviewAdd(args, recursive)
+				if err != nil {
 					return err
 				}
 
+				// Display preview output
+				if recursive {
+					printf(cmd, "🔍 \033[1mWould add %d files recursively:\033[0m\n", len(files))
+				} else {
+					printf(cmd, "🔍 \033[1mWould add %d files:\033[0m\n", len(files))
+				}
+
+				// List files that would be added
+				for _, file := range files {
+					basename := filepath.Base(file)
+					printf(cmd, "   📄 \033[90m%s\033[0m\n", basename)
+				}
+
+				printf(cmd, "\n💡 \033[33mTo proceed:\033[0m run without --dry-run flag\n")
+				return nil
+			}
+
+			// Handle recursive mode
+			if recursive {
+				// Get preview to count files first for better output
+				previewFiles, err := lnk.PreviewAdd(args, recursive)
+				if err != nil {
+					return err
+				}
+
+				// Create progress callback for CLI display
+				progressCallback := func(current, total int, currentFile string) {
+					printf(cmd, "\r⏳ Processing %d/%d: %s", current, total, currentFile)
+				}
+
+				if err := lnk.AddRecursiveWithProgress(args, progressCallback); err != nil {
+					return err
+				}
+
+				// Clear progress line and show completion
+				printf(cmd, "\r")
+
+				// Store processed file count for display
+				args = previewFiles // Replace args with actual files for display
+			} else {
+				// Use appropriate method based on number of files
+				if len(args) == 1 {
+					// Single file - use existing Add method for backward compatibility
+					if err := lnk.Add(args[0]); err != nil {
+						return err
+					}
+				} else {
+					// Multiple files - use AddMultiple for atomic operation
+					if err := lnk.AddMultiple(args); err != nil {
+						return err
+					}
+				}
+			}
+
+			// Display results
+			if recursive {
+				// Recursive mode - show enhanced message with count
+				if host != "" {
+					printf(cmd, "✨ \033[1mAdded %d files recursively to lnk (host: %s)\033[0m\n", len(args), host)
+				} else {
+					printf(cmd, "✨ \033[1mAdded %d files recursively to lnk\033[0m\n", len(args))
+				}
+
+				// Show some of the files that were added (limit to first few for readability)
+				filesToShow := len(args)
+				if filesToShow > 5 {
+					filesToShow = 5
+				}
+
+				for i := 0; i < filesToShow; i++ {
+					basename := filepath.Base(args[i])
+					if host != "" {
+						printf(cmd, "   🔗 \033[90m%s\033[0m → \033[36m~/.config/lnk/%s.lnk/...\033[0m\n", basename, host)
+					} else {
+						printf(cmd, "   🔗 \033[90m%s\033[0m → \033[36m~/.config/lnk/...\033[0m\n", basename)
+					}
+				}
+
+				if len(args) > 5 {
+					printf(cmd, "   \033[90m... and %d more files\033[0m\n", len(args)-5)
+				}
+			} else if len(args) == 1 {
+				// Single file - maintain existing output format for backward compatibility
+				filePath := args[0]
 				basename := filepath.Base(filePath)
 				if host != "" {
 					printf(cmd, "✨ \033[1mAdded %s to lnk (host: %s)\033[0m\n", basename, host)
@@ -33,11 +133,32 @@ func newAddCmd() *cobra.Command {
 					printf(cmd, "✨ \033[1mAdded %s to lnk\033[0m\n", basename)
 					printf(cmd, "   🔗 \033[90m%s\033[0m → \033[36m~/.config/lnk/%s\033[0m\n", filePath, filePath)
 				}
+			} else {
+				// Multiple files - show summary
+				if host != "" {
+					printf(cmd, "✨ \033[1mAdded %d items to lnk (host: %s)\033[0m\n", len(args), host)
+				} else {
+					printf(cmd, "✨ \033[1mAdded %d items to lnk\033[0m\n", len(args))
+				}
+
+				// List each added file
+				for _, filePath := range args {
+					basename := filepath.Base(filePath)
+					if host != "" {
+						printf(cmd, "   🔗 \033[90m%s\033[0m → \033[36m~/.config/lnk/%s.lnk/...\033[0m\n", basename, host)
+					} else {
+						printf(cmd, "   🔗 \033[90m%s\033[0m → \033[36m~/.config/lnk/...\033[0m\n", basename)
+					}
+				}
+			}
+
 			printf(cmd, "   📝 Use \033[1mlnk push\033[0m to sync to remote\n")
 			return nil
 		},
 	}
 
 	cmd.Flags().StringP("host", "H", "", "Manage file for specific host (default: common configuration)")
+	cmd.Flags().BoolP("recursive", "r", false, "Add directory contents individually instead of the directory as a whole")
+	cmd.Flags().BoolP("dry-run", "n", false, "Show what would be added without making changes")
 	return cmd
 }

cmd/bootstrap.go

@@ -0,0 +1,45 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/yarlson/lnk/internal/core"
+)
+
+func newBootstrapCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:           "bootstrap",
+		Short:         "🚀 Run the bootstrap script to set up your environment",
+		Long:          "Executes the bootstrap script from your dotfiles repository to install dependencies and configure your system.",
+		SilenceUsage:  true,
+		SilenceErrors: true,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			lnk := core.NewLnk()
+
+			scriptPath, err := lnk.FindBootstrapScript()
+			if err != nil {
+				return err
+			}
+
+			if scriptPath == "" {
+				printf(cmd, "💡 \033[33mNo bootstrap script found\033[0m\n")
+				printf(cmd, "   📝 Create a \033[1mbootstrap.sh\033[0m file in your dotfiles repository:\n")
+				printf(cmd, "      \033[90m#!/bin/bash\033[0m\n")
+				printf(cmd, "      \033[90mecho \"Setting up environment...\"\033[0m\n")
+				printf(cmd, "      \033[90m# Your setup commands here\033[0m\n")
+				return nil
+			}
+
+			printf(cmd, "🚀 \033[1mRunning bootstrap script\033[0m\n")
+			printf(cmd, "   📄 Script: \033[36m%s\033[0m\n", scriptPath)
+			printf(cmd, "\n")
+
+			if err := lnk.RunBootstrapScript(scriptPath); err != nil {
+				return err
+			}
+
+			printf(cmd, "\n✅ \033[1;32mBootstrap completed successfully!\033[0m\n")
+			printf(cmd, "   🎉 Your environment is ready to use\n")
+			return nil
+		},
+	}
+}

cmd/init.go

@@ -14,9 +14,18 @@ func newInitCmd() *cobra.Command {
 		SilenceErrors: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			remote, _ := cmd.Flags().GetString("remote")
+			noBootstrap, _ := cmd.Flags().GetBool("no-bootstrap")
+			force, _ := cmd.Flags().GetBool("force")
 
 			lnk := core.NewLnk()
-			if err := lnk.InitWithRemote(remote); err != nil {
+
+			// Show warning when force is used and there are managed files to overwrite
+			if force && remote != "" && lnk.HasUserContent() {
+				printf(cmd, "⚠️  \033[33mUsing --force flag: This will overwrite existing managed files\033[0m\n")
+				printf(cmd, "   💡 Only use this if you understand the risks\n\n")
+			}
+
+			if err := lnk.InitWithRemoteForce(remote, force); err != nil {
 				return err
 			}
 
@@ -24,6 +33,33 @@ func newInitCmd() *cobra.Command {
 				printf(cmd, "🎯 \033[1mInitialized lnk repository\033[0m\n")
 				printf(cmd, "   📦 Cloned from: \033[36m%s\033[0m\n", remote)
 				printf(cmd, "   📁 Location: \033[90m~/.config/lnk\033[0m\n")
+
+				// Try to run bootstrap script if not disabled
+				if !noBootstrap {
+					printf(cmd, "\n🔍 \033[1mLooking for bootstrap script...\033[0m\n")
+
+					scriptPath, err := lnk.FindBootstrapScript()
+					if err != nil {
+						return err
+					}
+
+					if scriptPath != "" {
+						printf(cmd, "   ✅ Found bootstrap script: \033[36m%s\033[0m\n", scriptPath)
+						printf(cmd, "\n🚀 \033[1mRunning bootstrap script...\033[0m\n")
+						printf(cmd, "\n")
+
+						if err := lnk.RunBootstrapScript(scriptPath); err != nil {
+							printf(cmd, "\n⚠️  \033[33mBootstrap script failed, but repository was initialized successfully\033[0m\n")
+							printf(cmd, "   💡 You can run it manually with: \033[1mlnk bootstrap\033[0m\n")
+							printf(cmd, "   🔧 Error: %v\n", err)
+						} else {
+							printf(cmd, "\n✅ \033[1;32mBootstrap completed successfully!\033[0m\n")
+						}
+					} else {
+						printf(cmd, "   💡 No bootstrap script found\n")
+					}
+				}
+
 				printf(cmd, "\n💡 \033[33mNext steps:\033[0m\n")
 				printf(cmd, "   • Run \033[1mlnk pull\033[0m to restore symlinks\n")
 				printf(cmd, "   • Use \033[1mlnk add <file>\033[0m to manage new files\n")
@@ -40,5 +76,7 @@ func newInitCmd() *cobra.Command {
 	}
 
 	cmd.Flags().StringP("remote", "r", "", "Clone from remote URL instead of creating empty repository")
+	cmd.Flags().Bool("no-bootstrap", false, "Skip automatic execution of bootstrap script after cloning")
+	cmd.Flags().Bool("force", false, "Force initialization even if directory contains managed files (WARNING: This will overwrite existing content)")
 	return cmd
 }

cmd/root.go

@@ -20,16 +20,23 @@ func NewRootCommand() *cobra.Command {
 		Long: `🔗 Lnk - Git-native dotfiles management that doesn't suck.
 
 Move your dotfiles to ~/.config/lnk, symlink them back, and use Git like normal.
-Supports both common configurations and host-specific setups.
+Supports both common configurations, host-specific setups, and bulk operations for multiple files.
 
 ✨ Examples:
   lnk init                           # Fresh start
-  lnk init -r <repo-url>           # Clone existing dotfiles
+  lnk init -r <repo-url>             # Clone existing dotfiles (runs bootstrap automatically)
   lnk add ~/.vimrc ~/.bashrc         # Start managing common files
+  lnk add --recursive ~/.config/nvim # Add directory contents individually
+  lnk add --dry-run ~/.gitconfig     # Preview changes without applying
   lnk add --host work ~/.ssh/config  # Manage host-specific files
   lnk list --all                     # Show all configurations
   lnk pull --host work               # Pull host-specific changes
   lnk push "setup complete"          # Sync to remote
+  lnk bootstrap                      # Run bootstrap script manually
+
+🚀 Bootstrap Support:
+  Automatically runs bootstrap.sh when cloning a repository.
+  Use --no-bootstrap to disable.
 
 🎯 Simple, fast, Git-native, and multi-host ready.`,
 		SilenceUsage:  true,
@@ -45,6 +52,7 @@ Supports both common configurations and host-specific setups.
 	rootCmd.AddCommand(newStatusCmd())
 	rootCmd.AddCommand(newPushCmd())
 	rootCmd.AddCommand(newPullCmd())
+	rootCmd.AddCommand(newBootstrapCmd())
 
 	return rootCmd
 }

install.sh

@@ -18,7 +18,7 @@ INSTALL_DIR="/usr/local/bin"
 BINARY_NAME="lnk"
 
 # Fallback version if redirect fails
-FALLBACK_VERSION="v0.0.2"
+FALLBACK_VERSION="v0.3.0"
 
 # Detect OS and architecture
 detect_platform() {

internal/core/lnk.go

@@ -3,6 +3,7 @@ package core
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -45,6 +46,34 @@ func NewLnk(opts ...Option) *Lnk {
 	return lnk
 }
 
+// HasUserContent checks if the repository contains managed files
+// by looking for .lnk tracker files (common or host-specific)
+func (l *Lnk) HasUserContent() bool {
+	// Check for common tracker file
+	commonTracker := filepath.Join(l.repoPath, ".lnk")
+	if _, err := os.Stat(commonTracker); err == nil {
+		return true
+	}
+
+	// Check for host-specific tracker files if host is set
+	if l.host != "" {
+		hostTracker := filepath.Join(l.repoPath, fmt.Sprintf(".lnk.%s", l.host))
+		if _, err := os.Stat(hostTracker); err == nil {
+			return true
+		}
+	} else {
+		// If no specific host is set, check for any host-specific tracker files
+		// This handles cases where we want to detect any managed content
+		pattern := filepath.Join(l.repoPath, ".lnk.*")
+		matches, err := filepath.Glob(pattern)
+		if err == nil && len(matches) > 0 {
+			return true
+		}
+	}
+
+	return false
+}
+
 // GetCurrentHostname returns the current system hostname
 func GetCurrentHostname() (string, error) {
 	hostname, err := os.Hostname()
@@ -118,7 +147,18 @@ func (l *Lnk) Init() error {
 
 // InitWithRemote initializes the lnk repository, optionally cloning from a remote
 func (l *Lnk) InitWithRemote(remoteURL string) error {
+	return l.InitWithRemoteForce(remoteURL, false)
+}
+
+// InitWithRemoteForce initializes the lnk repository with optional force override
+func (l *Lnk) InitWithRemoteForce(remoteURL string, force bool) error {
 	if remoteURL != "" {
+		// Safety check: prevent data loss by checking for existing managed files
+		if l.HasUserContent() {
+			if !force {
+				return fmt.Errorf("❌ Directory \033[31m%s\033[0m already contains managed files\n   💡 Use 'lnk pull' to update from remote instead of 'lnk init -r'", l.repoPath)
+			}
+		}
 		// Clone from remote
 		return l.Clone(remoteURL)
 	}
@@ -256,6 +296,153 @@ func (l *Lnk) Add(filePath string) error {
 	return nil
 }
 
+// AddMultiple adds multiple files or directories to the repository in a single transaction
+func (l *Lnk) AddMultiple(paths []string) error {
+	if len(paths) == 0 {
+		return nil
+	}
+
+	// Phase 1: Validate all paths first
+	var relativePaths []string
+	var absolutePaths []string
+	var infos []os.FileInfo
+
+	for _, filePath := range paths {
+		// Validate the file or directory
+		if err := l.fs.ValidateFileForAdd(filePath); err != nil {
+			return fmt.Errorf("validation failed for %s: %w", filePath, err)
+		}
+
+		// Get absolute path
+		absPath, err := filepath.Abs(filePath)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path for %s: %w", filePath, err)
+		}
+
+		// Get relative path for tracking
+		relativePath, err := getRelativePath(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to get relative path for %s: %w", filePath, err)
+		}
+
+		// Check if this relative path is already managed
+		managedItems, err := l.getManagedItems()
+		if err != nil {
+			return fmt.Errorf("failed to get managed items: %w", err)
+		}
+		for _, item := range managedItems {
+			if item == relativePath {
+				return fmt.Errorf("❌ File is already managed by lnk: \033[31m%s\033[0m", relativePath)
+			}
+		}
+
+		// Get file info
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to stat path %s: %w", filePath, err)
+		}
+
+		relativePaths = append(relativePaths, relativePath)
+		absolutePaths = append(absolutePaths, absPath)
+		infos = append(infos, info)
+	}
+
+	// Phase 2: Process all files - move to repository and create symlinks
+	var rollbackActions []func() error
+
+	for i, absPath := range absolutePaths {
+		relativePath := relativePaths[i]
+		info := infos[i]
+
+		// Generate repository path from relative path
+		storagePath := l.getHostStoragePath()
+		destPath := filepath.Join(storagePath, relativePath)
+
+		// Ensure destination directory exists
+		destDir := filepath.Dir(destPath)
+		if err := os.MkdirAll(destDir, 0755); err != nil {
+			// Rollback previous operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to create destination directory: %w", err)
+		}
+
+		// Move to repository
+		if err := l.fs.Move(absPath, destPath, info); err != nil {
+			// Rollback previous operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to move %s: %w", absPath, err)
+		}
+
+		// Create symlink
+		if err := l.fs.CreateSymlink(destPath, absPath); err != nil {
+			// Try to restore the file we just moved, then rollback others
+			_ = l.fs.Move(destPath, absPath, info)
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to create symlink for %s: %w", absPath, err)
+		}
+
+		// Add to tracking
+		if err := l.addManagedItem(relativePath); err != nil {
+			// Restore this file and rollback others
+			_ = os.Remove(absPath)
+			_ = l.fs.Move(destPath, absPath, info)
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to update tracking file for %s: %w", absPath, err)
+		}
+
+		// Add rollback action for this file
+		rollbackAction := l.createRollbackAction(absPath, destPath, relativePath, info)
+		rollbackActions = append(rollbackActions, rollbackAction)
+	}
+
+	// Phase 3: Git operations - add all files and create single commit
+	for i, relativePath := range relativePaths {
+		// For host-specific files, we need to add the relative path from repo root
+		gitPath := relativePath
+		if l.host != "" {
+			gitPath = filepath.Join(l.host+".lnk", relativePath)
+		}
+		if err := l.git.Add(gitPath); err != nil {
+			// Rollback all operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to add %s to git: %w", absolutePaths[i], err)
+		}
+	}
+
+	// Add .lnk file to the same commit
+	if err := l.git.Add(l.getLnkFileName()); err != nil {
+		// Rollback all operations
+		l.rollbackOperations(rollbackActions)
+		return fmt.Errorf("failed to add tracking file to git: %w", err)
+	}
+
+	// Commit all changes together
+	commitMessage := fmt.Sprintf("lnk: added %d files", len(paths))
+	if err := l.git.Commit(commitMessage); err != nil {
+		// Rollback all operations
+		l.rollbackOperations(rollbackActions)
+		return fmt.Errorf("failed to commit changes: %w", err)
+	}
+
+	return nil
+}
+
+// createRollbackAction creates a rollback function for a single file operation
+func (l *Lnk) createRollbackAction(absPath, destPath, relativePath string, info os.FileInfo) func() error {
+	return func() error {
+		_ = os.Remove(absPath)
+		_ = l.removeManagedItem(relativePath)
+		return l.fs.Move(destPath, absPath, info)
+	}
+}
+
+// rollbackOperations executes rollback actions in reverse order
+func (l *Lnk) rollbackOperations(rollbackActions []func() error) {
+	for i := len(rollbackActions) - 1; i >= 0; i-- {
+		_ = rollbackActions[i]()
+	}
+}
+
 // Remove removes a symlink and restores the original file or directory
 func (l *Lnk) Remove(filePath string) error {
 	// Get absolute path
@@ -630,3 +817,373 @@ func (l *Lnk) writeManagedItems(items []string) error {
 
 	return nil
 }
+
+// FindBootstrapScript searches for a bootstrap script in the repository
+func (l *Lnk) FindBootstrapScript() (string, error) {
+	// Check if repository is initialized
+	if !l.git.IsGitRepository() {
+		return "", fmt.Errorf("❌ Lnk repository not initialized\n   💡 Run \033[1mlnk init\033[0m first")
+	}
+
+	// Look for bootstrap.sh - simple, opinionated choice
+	scriptPath := filepath.Join(l.repoPath, "bootstrap.sh")
+	if _, err := os.Stat(scriptPath); err == nil {
+		return "bootstrap.sh", nil
+	}
+
+	return "", nil // No bootstrap script found
+}
+
+// RunBootstrapScript executes the bootstrap script
+func (l *Lnk) RunBootstrapScript(scriptName string) error {
+	scriptPath := filepath.Join(l.repoPath, scriptName)
+
+	// Verify the script exists
+	if _, err := os.Stat(scriptPath); os.IsNotExist(err) {
+		return fmt.Errorf("❌ Bootstrap script not found: \033[31m%s\033[0m", scriptName)
+	}
+
+	// Make sure it's executable
+	if err := os.Chmod(scriptPath, 0755); err != nil {
+		return fmt.Errorf("❌ Failed to make bootstrap script executable: %w", err)
+	}
+
+	// Run with bash (since we only support bootstrap.sh)
+	cmd := exec.Command("bash", scriptPath)
+
+	// Set working directory to the repository
+	cmd.Dir = l.repoPath
+
+	// Connect to stdout/stderr for user to see output
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+
+	// Run the script
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("❌ Bootstrap script failed with error: %w", err)
+	}
+
+	return nil
+}
+
+// walkDirectory walks through a directory and returns all regular files
+func (l *Lnk) walkDirectory(dirPath string) ([]string, error) {
+	var files []string
+
+	err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip directories - we only want files
+		if info.IsDir() {
+			return nil
+		}
+
+		// Handle symlinks: include them as files if they point to regular files
+		if info.Mode()&os.ModeSymlink != 0 {
+			// For symlinks, we'll include them but the AddMultiple logic
+			// will handle validation appropriately
+			files = append(files, path)
+			return nil
+		}
+
+		// Include regular files
+		if info.Mode().IsRegular() {
+			files = append(files, path)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to walk directory %s: %w", dirPath, err)
+	}
+
+	return files, nil
+}
+
+// ProgressCallback defines the signature for progress reporting callbacks
+type ProgressCallback func(current, total int, currentFile string)
+
+// AddRecursiveWithProgress adds directory contents individually with progress reporting
+func (l *Lnk) AddRecursiveWithProgress(paths []string, progress ProgressCallback) error {
+	var allFiles []string
+
+	for _, path := range paths {
+		// Get absolute path
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path for %s: %w", path, err)
+		}
+
+		// Check if it's a directory
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to stat %s: %w", path, err)
+		}
+
+		if info.IsDir() {
+			// Walk directory to get all files
+			files, err := l.walkDirectory(absPath)
+			if err != nil {
+				return fmt.Errorf("failed to walk directory %s: %w", path, err)
+			}
+			allFiles = append(allFiles, files...)
+		} else {
+			// It's a regular file, add it directly
+			allFiles = append(allFiles, absPath)
+		}
+	}
+
+	// Use AddMultiple for batch processing
+	if len(allFiles) == 0 {
+		return fmt.Errorf("no files found to add")
+	}
+
+	// Apply progress threshold: only show progress for >10 files
+	const progressThreshold = 10
+	if len(allFiles) > progressThreshold && progress != nil {
+		return l.addMultipleWithProgress(allFiles, progress)
+	}
+
+	// For small operations, use regular AddMultiple without progress
+	return l.AddMultiple(allFiles)
+}
+
+// addMultipleWithProgress adds multiple files with progress reporting
+func (l *Lnk) addMultipleWithProgress(paths []string, progress ProgressCallback) error {
+	if len(paths) == 0 {
+		return nil
+	}
+
+	// Phase 1: Validate all paths first (same as AddMultiple)
+	var relativePaths []string
+	var absolutePaths []string
+	var infos []os.FileInfo
+
+	for _, filePath := range paths {
+		// Validate the file or directory
+		if err := l.fs.ValidateFileForAdd(filePath); err != nil {
+			return fmt.Errorf("validation failed for %s: %w", filePath, err)
+		}
+
+		// Get absolute path
+		absPath, err := filepath.Abs(filePath)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path for %s: %w", filePath, err)
+		}
+
+		// Get relative path for tracking
+		relativePath, err := getRelativePath(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to get relative path for %s: %w", filePath, err)
+		}
+
+		// Check if this relative path is already managed
+		managedItems, err := l.getManagedItems()
+		if err != nil {
+			return fmt.Errorf("failed to get managed items: %w", err)
+		}
+		for _, item := range managedItems {
+			if item == relativePath {
+				return fmt.Errorf("❌ File is already managed by lnk: \033[31m%s\033[0m", relativePath)
+			}
+		}
+
+		// Get file info
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to stat path %s: %w", filePath, err)
+		}
+
+		relativePaths = append(relativePaths, relativePath)
+		absolutePaths = append(absolutePaths, absPath)
+		infos = append(infos, info)
+	}
+
+	// Phase 2: Process all files with progress reporting
+	var rollbackActions []func() error
+	total := len(absolutePaths)
+
+	for i, absPath := range absolutePaths {
+		// Report progress
+		if progress != nil {
+			progress(i+1, total, filepath.Base(absPath))
+		}
+
+		relativePath := relativePaths[i]
+		info := infos[i]
+
+		// Generate repository path from relative path
+		storagePath := l.getHostStoragePath()
+		destPath := filepath.Join(storagePath, relativePath)
+
+		// Ensure destination directory exists
+		destDir := filepath.Dir(destPath)
+		if err := os.MkdirAll(destDir, 0755); err != nil {
+			// Rollback previous operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to create destination directory: %w", err)
+		}
+
+		// Move to repository
+		if err := l.fs.Move(absPath, destPath, info); err != nil {
+			// Rollback previous operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to move %s: %w", absPath, err)
+		}
+
+		// Create symlink
+		if err := l.fs.CreateSymlink(destPath, absPath); err != nil {
+			// Try to restore the file we just moved, then rollback others
+			_ = l.fs.Move(destPath, absPath, info)
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to create symlink for %s: %w", absPath, err)
+		}
+
+		// Add to tracking
+		if err := l.addManagedItem(relativePath); err != nil {
+			// Restore this file and rollback others
+			_ = os.Remove(absPath)
+			_ = l.fs.Move(destPath, absPath, info)
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to update tracking file for %s: %w", absPath, err)
+		}
+
+		// Add rollback action for this file
+		rollbackAction := l.createRollbackAction(absPath, destPath, relativePath, info)
+		rollbackActions = append(rollbackActions, rollbackAction)
+	}
+
+	// Phase 3: Git operations - add all files and create single commit
+	for i, relativePath := range relativePaths {
+		// For host-specific files, we need to add the relative path from repo root
+		gitPath := relativePath
+		if l.host != "" {
+			gitPath = filepath.Join(l.host+".lnk", relativePath)
+		}
+		if err := l.git.Add(gitPath); err != nil {
+			// Rollback all operations
+			l.rollbackOperations(rollbackActions)
+			return fmt.Errorf("failed to add %s to git: %w", absolutePaths[i], err)
+		}
+	}
+
+	// Add .lnk file to the same commit
+	if err := l.git.Add(l.getLnkFileName()); err != nil {
+		// Rollback all operations
+		l.rollbackOperations(rollbackActions)
+		return fmt.Errorf("failed to add tracking file to git: %w", err)
+	}
+
+	// Commit all changes together
+	commitMessage := fmt.Sprintf("lnk: added %d files recursively", len(paths))
+	if err := l.git.Commit(commitMessage); err != nil {
+		// Rollback all operations
+		l.rollbackOperations(rollbackActions)
+		return fmt.Errorf("failed to commit changes: %w", err)
+	}
+
+	return nil
+}
+
+// AddRecursive adds directory contents individually instead of the directory as a whole
+func (l *Lnk) AddRecursive(paths []string) error {
+	var allFiles []string
+
+	for _, path := range paths {
+		// Get absolute path
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path for %s: %w", path, err)
+		}
+
+		// Check if it's a directory
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return fmt.Errorf("failed to stat %s: %w", path, err)
+		}
+
+		if info.IsDir() {
+			// Walk directory to get all files
+			files, err := l.walkDirectory(absPath)
+			if err != nil {
+				return fmt.Errorf("failed to walk directory %s: %w", path, err)
+			}
+			allFiles = append(allFiles, files...)
+		} else {
+			// It's a regular file, add it directly
+			allFiles = append(allFiles, absPath)
+		}
+	}
+
+	// Use AddMultiple for batch processing
+	if len(allFiles) == 0 {
+		return fmt.Errorf("no files found to add")
+	}
+
+	return l.AddMultiple(allFiles)
+}
+
+// PreviewAdd simulates an add operation and returns files that would be affected
+func (l *Lnk) PreviewAdd(paths []string, recursive bool) ([]string, error) {
+	var allFiles []string
+
+	for _, path := range paths {
+		// Get absolute path
+		absPath, err := filepath.Abs(path)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get absolute path for %s: %w", path, err)
+		}
+
+		// Check if it's a directory
+		info, err := os.Stat(absPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to stat %s: %w", path, err)
+		}
+
+		if info.IsDir() && recursive {
+			// Walk directory to get all files (same logic as AddRecursive)
+			files, err := l.walkDirectory(absPath)
+			if err != nil {
+				return nil, fmt.Errorf("failed to walk directory %s: %w", path, err)
+			}
+			allFiles = append(allFiles, files...)
+		} else {
+			// It's a regular file or non-recursive directory, add it directly
+			allFiles = append(allFiles, absPath)
+		}
+	}
+
+	// Validate files (same validation as AddMultiple but without making changes)
+	var validFiles []string
+	for _, filePath := range allFiles {
+		// Validate the file or directory
+		if err := l.fs.ValidateFileForAdd(filePath); err != nil {
+			return nil, fmt.Errorf("validation failed for %s: %w", filePath, err)
+		}
+
+		// Get relative path for tracking
+		relativePath, err := getRelativePath(filePath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get relative path for %s: %w", filePath, err)
+		}
+
+		// Check if this relative path is already managed
+		managedItems, err := l.getManagedItems()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get managed items: %w", err)
+		}
+		for _, item := range managedItems {
+			if item == relativePath {
+				return nil, fmt.Errorf("❌ File is already managed by lnk: \033[31m%s\033[0m", relativePath)
+			}
+		}
+
+		validFiles = append(validFiles, filePath)
+	}
+
+	return validFiles, nil
+}

internal/core/lnk_test.go

@@ -1,7 +1,9 @@
 package core
 
 import (
+	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -30,6 +32,9 @@ func (suite *CoreTestSuite) SetupTest() {
 	err = os.Chdir(tempDir)
 	suite.Require().NoError(err)
 
+	// Set HOME to temp directory for consistent relative path calculation
+	suite.T().Setenv("HOME", tempDir)
+
 	// Set XDG_CONFIG_HOME to temp directory
 	suite.T().Setenv("XDG_CONFIG_HOME", tempDir)
 
@@ -85,8 +90,8 @@ func (suite *CoreTestSuite) TestCoreFileOperations() {
 	// The repository file will preserve the directory structure
 	lnkDir := filepath.Join(suite.tempDir, "lnk")
 
-	// Find the .bashrc file in the repository (it should be at the relative path)
+	// Find the .bashrc file in the repository (it should be at the relative path from HOME)
-	repoFile := filepath.Join(lnkDir, suite.tempDir, ".bashrc")
+	repoFile := filepath.Join(lnkDir, ".bashrc")
 	suite.FileExists(repoFile)
 
 	// Verify content is preserved
@@ -136,8 +141,8 @@ func (suite *CoreTestSuite) TestCoreDirectoryOperations() {
 	// Check that the repository directory preserves the structure
 	lnkDir := filepath.Join(suite.tempDir, "lnk")
 
-	// The directory should be at the relative path
+	// The directory should be at the relative path from HOME
-	repoDir := filepath.Join(lnkDir, suite.tempDir, "testdir")
+	repoDir := filepath.Join(lnkDir, "testdir")
 	suite.DirExists(repoDir)
 
 	// Remove the directory
@@ -749,6 +754,849 @@ func (suite *CoreTestSuite) TestMultihostIsolation() {
 	suite.Equal(hostContent, string(symlinkContent))
 }
 
+// Test bootstrap script detection
+func (suite *CoreTestSuite) TestFindBootstrapScript() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Test with no bootstrap script
+	scriptPath, err := suite.lnk.FindBootstrapScript()
+	suite.NoError(err)
+	suite.Empty(scriptPath)
+
+	// Test with bootstrap.sh
+	bootstrapScript := filepath.Join(suite.tempDir, "lnk", "bootstrap.sh")
+	err = os.WriteFile(bootstrapScript, []byte("#!/bin/bash\necho 'test'"), 0644)
+	suite.Require().NoError(err)
+
+	scriptPath, err = suite.lnk.FindBootstrapScript()
+	suite.NoError(err)
+	suite.Equal("bootstrap.sh", scriptPath)
+}
+
+// Test bootstrap script execution
+func (suite *CoreTestSuite) TestRunBootstrapScript() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create a test script that creates a marker file
+	bootstrapScript := filepath.Join(suite.tempDir, "lnk", "test.sh")
+	markerFile := filepath.Join(suite.tempDir, "lnk", "bootstrap-executed.txt")
+	scriptContent := fmt.Sprintf("#!/bin/bash\ntouch %s\necho 'Bootstrap executed'", markerFile)
+
+	err = os.WriteFile(bootstrapScript, []byte(scriptContent), 0755)
+	suite.Require().NoError(err)
+
+	// Run the bootstrap script
+	err = suite.lnk.RunBootstrapScript("test.sh")
+	suite.NoError(err)
+
+	// Verify the marker file was created
+	suite.FileExists(markerFile)
+}
+
+// Test bootstrap script execution with error
+func (suite *CoreTestSuite) TestRunBootstrapScriptWithError() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create a script that will fail
+	bootstrapScript := filepath.Join(suite.tempDir, "lnk", "failing.sh")
+	scriptContent := "#!/bin/bash\nexit 1"
+
+	err = os.WriteFile(bootstrapScript, []byte(scriptContent), 0755)
+	suite.Require().NoError(err)
+
+	// Run the bootstrap script - should fail
+	err = suite.lnk.RunBootstrapScript("failing.sh")
+	suite.Error(err)
+	suite.Contains(err.Error(), "Bootstrap script failed")
+}
+
+// Test running bootstrap on non-existent script
+func (suite *CoreTestSuite) TestRunBootstrapScriptNotFound() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Try to run non-existent script
+	err = suite.lnk.RunBootstrapScript("nonexistent.sh")
+	suite.Error(err)
+	suite.Contains(err.Error(), "Bootstrap script not found")
+}
+
+func (suite *CoreTestSuite) TestAddMultiple() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create multiple test files
+	file1 := filepath.Join(suite.tempDir, "file1.txt")
+	file2 := filepath.Join(suite.tempDir, "file2.txt")
+	file3 := filepath.Join(suite.tempDir, "file3.txt")
+
+	content1 := "content1"
+	content2 := "content2"
+	content3 := "content3"
+
+	err = os.WriteFile(file1, []byte(content1), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file2, []byte(content2), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file3, []byte(content3), 0644)
+	suite.Require().NoError(err)
+
+	// Test AddMultiple method - should succeed
+	paths := []string{file1, file2, file3}
+	err = suite.lnk.AddMultiple(paths)
+	suite.NoError(err, "AddMultiple should succeed")
+
+	// Verify all files are now symlinks
+	for _, file := range paths {
+		info, err := os.Lstat(file)
+		suite.NoError(err)
+		suite.Equal(os.ModeSymlink, info.Mode()&os.ModeSymlink, "File should be a symlink: %s", file)
+	}
+
+	// Verify all files exist in storage
+	lnkDir := filepath.Join(suite.tempDir, "lnk")
+	suite.FileExists(filepath.Join(lnkDir, "file1.txt"))
+	suite.FileExists(filepath.Join(lnkDir, "file2.txt"))
+	suite.FileExists(filepath.Join(lnkDir, "file3.txt"))
+
+	// Verify .lnk file contains all entries
+	lnkFile := filepath.Join(lnkDir, ".lnk")
+	lnkContent, err := os.ReadFile(lnkFile)
+	suite.NoError(err)
+	suite.Equal("file1.txt\nfile2.txt\nfile3.txt\n", string(lnkContent))
+
+	// Verify Git commit was created
+	commits, err := suite.lnk.GetCommits()
+	suite.NoError(err)
+	suite.T().Logf("Commits: %v", commits)
+	// Should have at least 1 commit for the batch add
+	suite.GreaterOrEqual(len(commits), 1)
+	// The most recent commit should mention multiple files
+	suite.Contains(commits[0], "added 3 files")
+}
+
+func (suite *CoreTestSuite) TestAddMultipleWithConflicts() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create test files
+	file1 := filepath.Join(suite.tempDir, "file1.txt")
+	file2 := filepath.Join(suite.tempDir, "file2.txt")
+	file3 := filepath.Join(suite.tempDir, "file3.txt")
+
+	err = os.WriteFile(file1, []byte("content1"), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file2, []byte("content2"), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file3, []byte("content3"), 0644)
+	suite.Require().NoError(err)
+
+	// Add file2 individually first
+	err = suite.lnk.Add(file2)
+	suite.Require().NoError(err)
+
+	// Now try to add all three - should fail due to conflict with file2
+	paths := []string{file1, file2, file3}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "AddMultiple should fail due to conflict")
+	suite.Contains(err.Error(), "already managed")
+
+	// Verify no partial changes were made
+	// file1 and file3 should still be regular files, not symlinks
+	info1, err := os.Lstat(file1)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info1.Mode()&os.ModeSymlink, "file1 should not be a symlink")
+
+	info3, err := os.Lstat(file3)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info3.Mode()&os.ModeSymlink, "file3 should not be a symlink")
+
+	// file2 should still be managed (was added before)
+	info2, err := os.Lstat(file2)
+	suite.NoError(err)
+	suite.Equal(os.ModeSymlink, info2.Mode()&os.ModeSymlink, "file2 should remain a symlink")
+}
+
+func (suite *CoreTestSuite) TestAddMultipleRollback() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create test files - one will be invalid to force rollback
+	file1 := filepath.Join(suite.tempDir, "file1.txt")
+	file2 := filepath.Join(suite.tempDir, "nonexistent.txt") // This doesn't exist
+	file3 := filepath.Join(suite.tempDir, "file3.txt")
+
+	err = os.WriteFile(file1, []byte("content1"), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file3, []byte("content3"), 0644)
+	suite.Require().NoError(err)
+	// Note: file2 is intentionally not created
+
+	// Try to add all files - should fail and rollback
+	paths := []string{file1, file2, file3}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "AddMultiple should fail due to nonexistent file")
+
+	// Verify rollback - no files should be symlinks
+	info1, err := os.Lstat(file1)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info1.Mode()&os.ModeSymlink, "file1 should not be a symlink after rollback")
+
+	info3, err := os.Lstat(file3)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info3.Mode()&os.ModeSymlink, "file3 should not be a symlink after rollback")
+
+	// Verify no files in storage
+	lnkDir := filepath.Join(suite.tempDir, "lnk")
+	suite.NoFileExists(filepath.Join(lnkDir, "file1.txt"))
+	suite.NoFileExists(filepath.Join(lnkDir, "file3.txt"))
+
+	// Verify .lnk file is empty or doesn't contain these files
+	lnkFile := filepath.Join(lnkDir, ".lnk")
+	if _, err := os.Stat(lnkFile); err == nil {
+		lnkContent, err := os.ReadFile(lnkFile)
+		suite.NoError(err)
+		content := string(lnkContent)
+		suite.NotContains(content, "file1.txt")
+		suite.NotContains(content, "file3.txt")
+	}
+}
+
+func (suite *CoreTestSuite) TestValidateMultiplePaths() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create a mix of valid and invalid paths
+	validFile := filepath.Join(suite.tempDir, "valid.txt")
+	err = os.WriteFile(validFile, []byte("content"), 0644)
+	suite.Require().NoError(err)
+
+	nonexistentFile := filepath.Join(suite.tempDir, "nonexistent.txt")
+	// Don't create this file
+
+	// Create a valid directory
+	validDir := filepath.Join(suite.tempDir, "validdir")
+	err = os.MkdirAll(validDir, 0755)
+	suite.Require().NoError(err)
+
+	// Test validation fails early with detailed error
+	paths := []string{validFile, nonexistentFile, validDir}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "Should fail due to nonexistent file")
+	suite.Contains(err.Error(), "validation failed")
+	suite.Contains(err.Error(), "nonexistent.txt")
+
+	// Verify no partial changes were made
+	info, err := os.Lstat(validFile)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info.Mode()&os.ModeSymlink, "valid file should not be a symlink")
+
+	info, err = os.Lstat(validDir)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info.Mode()&os.ModeSymlink, "valid directory should not be a symlink")
+}
+
+func (suite *CoreTestSuite) TestAtomicRollbackOnFailure() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create test files
+	file1 := filepath.Join(suite.tempDir, "file1.txt")
+	file2 := filepath.Join(suite.tempDir, "file2.txt")
+	file3 := filepath.Join(suite.tempDir, "file3.txt")
+
+	content1 := "original content 1"
+	content2 := "original content 2"
+	content3 := "original content 3"
+
+	err = os.WriteFile(file1, []byte(content1), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file2, []byte(content2), 0644)
+	suite.Require().NoError(err)
+	err = os.WriteFile(file3, []byte(content3), 0644)
+	suite.Require().NoError(err)
+
+	// Add file2 individually first to create a conflict
+	err = suite.lnk.Add(file2)
+	suite.Require().NoError(err)
+
+	// Store original states
+	info1Before, err := os.Lstat(file1)
+	suite.Require().NoError(err)
+	info3Before, err := os.Lstat(file3)
+	suite.Require().NoError(err)
+
+	// Try to add all files - should fail and rollback completely
+	paths := []string{file1, file2, file3}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "Should fail due to conflict with file2")
+
+	// Verify complete rollback
+	info1After, err := os.Lstat(file1)
+	suite.NoError(err)
+	suite.Equal(info1Before.Mode(), info1After.Mode(), "file1 mode should be unchanged")
+
+	info3After, err := os.Lstat(file3)
+	suite.NoError(err)
+	suite.Equal(info3Before.Mode(), info3After.Mode(), "file3 mode should be unchanged")
+
+	// Verify original contents are preserved
+	content1After, err := os.ReadFile(file1)
+	suite.NoError(err)
+	suite.Equal(content1, string(content1After), "file1 content should be preserved")
+
+	content3After, err := os.ReadFile(file3)
+	suite.NoError(err)
+	suite.Equal(content3, string(content3After), "file3 content should be preserved")
+
+	// file2 should still be managed (was added before)
+	info2, err := os.Lstat(file2)
+	suite.NoError(err)
+	suite.Equal(os.ModeSymlink, info2.Mode()&os.ModeSymlink, "file2 should remain a symlink")
+}
+
+func (suite *CoreTestSuite) TestDetailedErrorMessages() {
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Test with multiple types of errors
+	validFile := filepath.Join(suite.tempDir, "valid.txt")
+	err = os.WriteFile(validFile, []byte("content"), 0644)
+	suite.Require().NoError(err)
+
+	nonexistentFile := filepath.Join(suite.tempDir, "does-not-exist.txt")
+	alreadyManagedFile := filepath.Join(suite.tempDir, "already-managed.txt")
+	err = os.WriteFile(alreadyManagedFile, []byte("managed"), 0644)
+	suite.Require().NoError(err)
+
+	// Add one file first to create conflict
+	err = suite.lnk.Add(alreadyManagedFile)
+	suite.Require().NoError(err)
+
+	// Test with nonexistent file
+	paths := []string{validFile, nonexistentFile}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "Should fail due to nonexistent file")
+	suite.Contains(err.Error(), "validation failed", "Error should mention validation failure")
+	suite.Contains(err.Error(), "does-not-exist.txt", "Error should include specific filename")
+
+	// Test with already managed file
+	paths = []string{validFile, alreadyManagedFile}
+	err = suite.lnk.AddMultiple(paths)
+	suite.Error(err, "Should fail due to already managed file")
+	suite.Contains(err.Error(), "already managed", "Error should mention already managed")
+	suite.Contains(err.Error(), "already-managed.txt", "Error should include specific filename")
+}
+
+// Task 2.2: Directory Walking Logic Tests
+
+func (suite *CoreTestSuite) TestWalkDirectory() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create nested directory structure
+	configDir := filepath.Join(suite.tempDir, ".config", "myapp")
+	err = os.MkdirAll(configDir, 0755)
+	suite.Require().NoError(err)
+
+	themeDir := filepath.Join(configDir, "themes")
+	err = os.MkdirAll(themeDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create files in different levels
+	file1 := filepath.Join(configDir, "config.json")
+	file2 := filepath.Join(configDir, "settings.json")
+	file3 := filepath.Join(themeDir, "dark.json")
+	file4 := filepath.Join(themeDir, "light.json")
+
+	suite.Require().NoError(os.WriteFile(file1, []byte("config"), 0644))
+	suite.Require().NoError(os.WriteFile(file2, []byte("settings"), 0644))
+	suite.Require().NoError(os.WriteFile(file3, []byte("dark theme"), 0644))
+	suite.Require().NoError(os.WriteFile(file4, []byte("light theme"), 0644))
+
+	// Call walkDirectory method (which doesn't exist yet)
+	files, err := suite.lnk.walkDirectory(configDir)
+	suite.Require().NoError(err, "walkDirectory should succeed")
+
+	// Should find all 4 files
+	suite.Len(files, 4, "Should find all files in nested structure")
+
+	// Check that all expected files are found (order may vary)
+	expectedFiles := []string{file1, file2, file3, file4}
+	for _, expectedFile := range expectedFiles {
+		suite.Contains(files, expectedFile, "Should include file %s", expectedFile)
+	}
+}
+
+func (suite *CoreTestSuite) TestWalkDirectoryIncludesHiddenFiles() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create directory with hidden files and directories
+	testDir := filepath.Join(suite.tempDir, "test-hidden")
+	err = os.MkdirAll(testDir, 0755)
+	suite.Require().NoError(err)
+
+	hiddenDir := filepath.Join(testDir, ".hidden")
+	err = os.MkdirAll(hiddenDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create regular and hidden files
+	regularFile := filepath.Join(testDir, "regular.txt")
+	hiddenFile := filepath.Join(testDir, ".hidden-file")
+	hiddenDirFile := filepath.Join(hiddenDir, "file-in-hidden.txt")
+
+	suite.Require().NoError(os.WriteFile(regularFile, []byte("regular"), 0644))
+	suite.Require().NoError(os.WriteFile(hiddenFile, []byte("hidden"), 0644))
+	suite.Require().NoError(os.WriteFile(hiddenDirFile, []byte("in hidden dir"), 0644))
+
+	// Call walkDirectory method
+	files, err := suite.lnk.walkDirectory(testDir)
+	suite.Require().NoError(err, "walkDirectory should succeed with hidden files")
+
+	// Should find all files including hidden ones
+	suite.Len(files, 3, "Should find all files including hidden ones")
+	suite.Contains(files, regularFile, "Should include regular file")
+	suite.Contains(files, hiddenFile, "Should include hidden file")
+	suite.Contains(files, hiddenDirFile, "Should include file in hidden directory")
+}
+
+func (suite *CoreTestSuite) TestWalkDirectorySymlinkHandling() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create directory structure
+	testDir := filepath.Join(suite.tempDir, "test-symlinks")
+	err = os.MkdirAll(testDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create a regular file
+	regularFile := filepath.Join(testDir, "regular.txt")
+	suite.Require().NoError(os.WriteFile(regularFile, []byte("regular"), 0644))
+
+	// Create a symlink to the regular file
+	symlinkFile := filepath.Join(testDir, "link-to-regular.txt")
+	err = os.Symlink(regularFile, symlinkFile)
+	suite.Require().NoError(err)
+
+	// Call walkDirectory method
+	files, err := suite.lnk.walkDirectory(testDir)
+	suite.Require().NoError(err, "walkDirectory should handle symlinks")
+
+	// Should include both regular file and properly handle symlink
+	// (exact behavior depends on implementation - could include symlink as file)
+	suite.GreaterOrEqual(len(files), 1, "Should find at least the regular file")
+	suite.Contains(files, regularFile, "Should include regular file")
+
+	// The symlink handling behavior will be defined in implementation
+	// For now, we just ensure no errors occur
+}
+
+func (suite *CoreTestSuite) TestWalkDirectoryEmptyDirs() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create directory structure with empty directories
+	testDir := filepath.Join(suite.tempDir, "test-empty")
+	err = os.MkdirAll(testDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create empty subdirectories
+	emptyDir1 := filepath.Join(testDir, "empty1")
+	emptyDir2 := filepath.Join(testDir, "empty2")
+	err = os.MkdirAll(emptyDir1, 0755)
+	suite.Require().NoError(err)
+	err = os.MkdirAll(emptyDir2, 0755)
+	suite.Require().NoError(err)
+
+	// Create one file in a non-empty directory
+	nonEmptyDir := filepath.Join(testDir, "non-empty")
+	err = os.MkdirAll(nonEmptyDir, 0755)
+	suite.Require().NoError(err)
+
+	testFile := filepath.Join(nonEmptyDir, "test.txt")
+	suite.Require().NoError(os.WriteFile(testFile, []byte("content"), 0644))
+
+	// Call walkDirectory method
+	files, err := suite.lnk.walkDirectory(testDir)
+	suite.Require().NoError(err, "walkDirectory should skip empty directories")
+
+	// Should only find the one file, not empty directories
+	suite.Len(files, 1, "Should only find files, not empty directories")
+	suite.Contains(files, testFile, "Should include the actual file")
+}
+
+// Task 2.3: Progress Indication System Tests
+
+func (suite *CoreTestSuite) TestProgressReporting() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create directory with multiple files to test progress reporting
+	testDir := filepath.Join(suite.tempDir, "progress-test")
+	err = os.MkdirAll(testDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create 15 files to exceed threshold
+	expectedFiles := 15
+	for i := 0; i < expectedFiles; i++ {
+		file := filepath.Join(testDir, fmt.Sprintf("file%d.txt", i))
+		suite.Require().NoError(os.WriteFile(file, []byte(fmt.Sprintf("content %d", i)), 0644))
+	}
+
+	// Track progress calls
+	var progressCalls []struct {
+		Current     int
+		Total       int
+		CurrentFile string
+	}
+
+	progressCallback := func(current, total int, currentFile string) {
+		progressCalls = append(progressCalls, struct {
+			Current     int
+			Total       int
+			CurrentFile string
+		}{
+			Current:     current,
+			Total:       total,
+			CurrentFile: currentFile,
+		})
+	}
+
+	// Call AddRecursiveWithProgress method (which doesn't exist yet)
+	err = suite.lnk.AddRecursiveWithProgress([]string{testDir}, progressCallback)
+	suite.Require().NoError(err, "AddRecursiveWithProgress should succeed")
+
+	// Verify progress was reported
+	suite.Greater(len(progressCalls), 0, "Progress callback should be called")
+	suite.Equal(expectedFiles, len(progressCalls), "Should have progress calls for each file")
+
+	// Verify progress order and totals
+	for i, call := range progressCalls {
+		suite.Equal(i+1, call.Current, "Current count should increment")
+		suite.Equal(expectedFiles, call.Total, "Total should be consistent")
+		suite.NotEmpty(call.CurrentFile, "CurrentFile should be provided")
+	}
+}
+
+func (suite *CoreTestSuite) TestProgressThreshold() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Test with few files (under threshold)
+	smallDir := filepath.Join(suite.tempDir, "small-test")
+	err = os.MkdirAll(smallDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create only 5 files (under 10 threshold)
+	for i := 0; i < 5; i++ {
+		file := filepath.Join(smallDir, fmt.Sprintf("small%d.txt", i))
+		suite.Require().NoError(os.WriteFile(file, []byte(fmt.Sprintf("content %d", i)), 0644))
+	}
+
+	// Track progress calls for small operation
+	smallProgressCalls := 0
+	smallCallback := func(current, total int, currentFile string) {
+		smallProgressCalls++
+	}
+
+	err = suite.lnk.AddRecursiveWithProgress([]string{smallDir}, smallCallback)
+	suite.Require().NoError(err, "AddRecursiveWithProgress should succeed for small operation")
+
+	// Should NOT call progress for small operations
+	suite.Equal(0, smallProgressCalls, "Progress should not be called for operations under threshold")
+
+	// Test with many files (over threshold)
+	largeDir := filepath.Join(suite.tempDir, "large-test")
+	err = os.MkdirAll(largeDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create 15 files (over 10 threshold)
+	for i := 0; i < 15; i++ {
+		file := filepath.Join(largeDir, fmt.Sprintf("large%d.txt", i))
+		suite.Require().NoError(os.WriteFile(file, []byte(fmt.Sprintf("content %d", i)), 0644))
+	}
+
+	// Track progress calls for large operation
+	largeProgressCalls := 0
+	largeCallback := func(current, total int, currentFile string) {
+		largeProgressCalls++
+	}
+
+	err = suite.lnk.AddRecursiveWithProgress([]string{largeDir}, largeCallback)
+	suite.Require().NoError(err, "AddRecursiveWithProgress should succeed for large operation")
+
+	// Should call progress for large operations
+	suite.Equal(15, largeProgressCalls, "Progress should be called for operations over threshold")
+}
+
+// Task 3.1: Dry-Run Mode Core Tests
+
+func (suite *CoreTestSuite) TestPreviewAdd() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create test files
+	testFile1 := filepath.Join(suite.tempDir, "test1.txt")
+	testFile2 := filepath.Join(suite.tempDir, "test2.txt")
+	suite.Require().NoError(os.WriteFile(testFile1, []byte("content1"), 0644))
+	suite.Require().NoError(os.WriteFile(testFile2, []byte("content2"), 0644))
+
+	// Test PreviewAdd for multiple files
+	files, err := suite.lnk.PreviewAdd([]string{testFile1, testFile2}, false)
+	suite.Require().NoError(err, "PreviewAdd should succeed")
+
+	// Should return both files
+	suite.Len(files, 2, "Should preview both files")
+	suite.Contains(files, testFile1, "Should include first file")
+	suite.Contains(files, testFile2, "Should include second file")
+
+	// Verify no actual changes were made (files should still be regular files)
+	info, err := os.Lstat(testFile1)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info.Mode()&os.ModeSymlink, "File should not be symlink after preview")
+
+	info, err = os.Lstat(testFile2)
+	suite.NoError(err)
+	suite.Equal(os.FileMode(0), info.Mode()&os.ModeSymlink, "File should not be symlink after preview")
+}
+
+func (suite *CoreTestSuite) TestPreviewAddRecursive() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create directory structure
+	configDir := filepath.Join(suite.tempDir, ".config", "test-app")
+	err = os.MkdirAll(configDir, 0755)
+	suite.Require().NoError(err)
+
+	// Create files in directory
+	expectedFiles := 5
+	var createdFiles []string
+	for i := 1; i <= expectedFiles; i++ {
+		file := filepath.Join(configDir, fmt.Sprintf("config%d.json", i))
+		suite.Require().NoError(os.WriteFile(file, []byte(fmt.Sprintf("config %d", i)), 0644))
+		createdFiles = append(createdFiles, file)
+	}
+
+	// Test PreviewAdd with recursive
+	files, err := suite.lnk.PreviewAdd([]string{configDir}, true)
+	suite.Require().NoError(err, "PreviewAdd recursive should succeed")
+
+	// Should return all files in directory
+	suite.Len(files, expectedFiles, "Should preview all files in directory")
+
+	// Check that all created files are included
+	for _, createdFile := range createdFiles {
+		suite.Contains(files, createdFile, "Should include file %s", createdFile)
+	}
+
+	// Verify no actual changes were made
+	for _, createdFile := range createdFiles {
+		info, err := os.Lstat(createdFile)
+		suite.NoError(err)
+		suite.Equal(os.FileMode(0), info.Mode()&os.ModeSymlink, "File should not be symlink after preview")
+	}
+}
+
+func (suite *CoreTestSuite) TestPreviewAddValidation() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Test with nonexistent file
+	nonexistentFile := filepath.Join(suite.tempDir, "nonexistent.txt")
+	_, err = suite.lnk.PreviewAdd([]string{nonexistentFile}, false)
+	suite.Error(err, "PreviewAdd should fail for nonexistent file")
+	suite.Contains(err.Error(), "failed to stat", "Error should mention stat failure")
+
+	// Create and add a file first
+	testFile := filepath.Join(suite.tempDir, "test.txt")
+	suite.Require().NoError(os.WriteFile(testFile, []byte("content"), 0644))
+	err = suite.lnk.Add(testFile)
+	suite.Require().NoError(err)
+
+	// Test preview with already managed file
+	_, err = suite.lnk.PreviewAdd([]string{testFile}, false)
+	suite.Error(err, "PreviewAdd should fail for already managed file")
+	suite.Contains(err.Error(), "already managed", "Error should mention already managed")
+}
+
+// Task 1.1: Tests for HasUserContent() method
+func (suite *CoreTestSuite) TestHasUserContent_WithCommonTracker_ReturnsTrue() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create .lnk file to simulate existing content
+	lnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk")
+	err = os.WriteFile(lnkFile, []byte(".bashrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// Call HasUserContent()
+	hasContent := suite.lnk.HasUserContent()
+	suite.True(hasContent, "Should detect common tracker file")
+}
+
+func (suite *CoreTestSuite) TestHasUserContent_WithHostTracker_ReturnsTrue() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create host-specific lnk instance
+	hostLnk := NewLnk(WithHost("testhost"))
+
+	// Create .lnk.hostname file to simulate host-specific content
+	lnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk.testhost")
+	err = os.WriteFile(lnkFile, []byte(".vimrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// Call HasUserContent()
+	hasContent := hostLnk.HasUserContent()
+	suite.True(hasContent, "Should detect host-specific tracker file")
+}
+
+func (suite *CoreTestSuite) TestHasUserContent_WithBothTrackers_ReturnsTrue() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create both common and host-specific tracker files
+	commonLnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk")
+	err = os.WriteFile(commonLnkFile, []byte(".bashrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	hostLnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk.testhost")
+	err = os.WriteFile(hostLnkFile, []byte(".vimrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// Test with common instance
+	hasContent := suite.lnk.HasUserContent()
+	suite.True(hasContent, "Should detect common tracker file")
+
+	// Test with host-specific instance
+	hostLnk := NewLnk(WithHost("testhost"))
+	hasContent = hostLnk.HasUserContent()
+	suite.True(hasContent, "Should detect host-specific tracker file")
+}
+
+func (suite *CoreTestSuite) TestHasUserContent_EmptyDirectory_ReturnsFalse() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Call HasUserContent() on empty repository
+	hasContent := suite.lnk.HasUserContent()
+	suite.False(hasContent, "Should return false for empty repository")
+}
+
+func (suite *CoreTestSuite) TestHasUserContent_NonTrackerFiles_ReturnsFalse() {
+	// Initialize lnk repository
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create non-tracker files
+	randomFile := filepath.Join(suite.tempDir, "lnk", "random.txt")
+	err = os.WriteFile(randomFile, []byte("some content"), 0644)
+	suite.Require().NoError(err)
+
+	configFile := filepath.Join(suite.tempDir, "lnk", ".gitignore")
+	err = os.WriteFile(configFile, []byte("*.log"), 0644)
+	suite.Require().NoError(err)
+
+	// Call HasUserContent()
+	hasContent := suite.lnk.HasUserContent()
+	suite.False(hasContent, "Should return false when only non-tracker files exist")
+}
+
+// Task 2.1: Tests for enhanced InitWithRemote() safety check
+func (suite *CoreTestSuite) TestInitWithRemote_HasUserContent_ReturnsError() {
+	// Initialize and add content first
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create .lnk file to simulate existing content
+	lnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk")
+	err = os.WriteFile(lnkFile, []byte(".bashrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// Try InitWithRemote - should fail
+	err = suite.lnk.InitWithRemote("https://github.com/test/dotfiles.git")
+	suite.Error(err, "Should fail when user content exists")
+	suite.Contains(err.Error(), "already contains managed files")
+	suite.Contains(err.Error(), "lnk pull")
+
+	// Verify .lnk file still exists (no deletion occurred)
+	suite.FileExists(lnkFile)
+}
+
+func (suite *CoreTestSuite) TestInitWithRemote_EmptyDirectory_Success() {
+	// Create a dummy remote directory for testing
+	remoteDir := filepath.Join(suite.tempDir, "remote")
+	err := os.MkdirAll(remoteDir, 0755)
+	suite.Require().NoError(err)
+
+	// Initialize a bare git repository as remote
+	cmd := exec.Command("git", "init", "--bare")
+	cmd.Dir = remoteDir
+	err = cmd.Run()
+	suite.Require().NoError(err)
+
+	// InitWithRemote should succeed on empty directory
+	err = suite.lnk.InitWithRemote(remoteDir)
+	suite.NoError(err, "Should succeed when no user content exists")
+
+	// Verify repository was cloned
+	lnkDir := filepath.Join(suite.tempDir, "lnk")
+	suite.DirExists(lnkDir)
+	gitDir := filepath.Join(lnkDir, ".git")
+	suite.DirExists(gitDir)
+}
+
+func (suite *CoreTestSuite) TestInitWithRemote_NoRemoteURL_BypassesSafetyCheck() {
+	// Initialize and add content first
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create .lnk file to simulate existing content
+	lnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk")
+	err = os.WriteFile(lnkFile, []byte(".bashrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// InitWithRemote with empty URL should bypass safety check (this is local init)
+	err = suite.lnk.InitWithRemote("")
+	suite.NoError(err, "Should bypass safety check when no remote URL provided")
+}
+
+func (suite *CoreTestSuite) TestInitWithRemote_ErrorMessage_ContainsSuggestedCommand() {
+	// Initialize and add content first
+	err := suite.lnk.Init()
+	suite.Require().NoError(err)
+
+	// Create host-specific content
+	hostLnk := NewLnk(WithHost("testhost"))
+	hostLnkFile := filepath.Join(suite.tempDir, "lnk", ".lnk.testhost")
+	err = os.WriteFile(hostLnkFile, []byte(".vimrc\n"), 0644)
+	suite.Require().NoError(err)
+
+	// Try InitWithRemote - should fail with helpful message
+	err = hostLnk.InitWithRemote("https://github.com/test/dotfiles.git")
+	suite.Error(err, "Should fail when user content exists")
+	suite.Contains(err.Error(), "lnk pull", "Should suggest pull command")
+	suite.Contains(err.Error(), "instead of", "Should explain alternative")
+}
+
 func TestCoreSuite(t *testing.T) {
 	suite.Run(t, new(CoreTestSuite))
 }

internal/git/git.go

@@ -437,7 +437,7 @@ func (g *Git) Push() error {
 		return &PushError{Reason: err.Error(), Err: err}
 	}
 
-	cmd := exec.Command("git", "push", "-u", "origin", "main")
+	cmd := exec.Command("git", "push", "-u", "origin")
 	cmd.Dir = g.repoPath
 
 	output, err := cmd.CombinedOutput()
@@ -456,7 +456,7 @@ func (g *Git) Pull() error {
 		return &PullError{Reason: err.Error(), Err: err}
 	}
 
-	cmd := exec.Command("git", "pull", "origin", "main")
+	cmd := exec.Command("git", "pull", "origin")
 	cmd.Dir = g.repoPath
 
 	output, err := cmd.CombinedOutput()