Add --dry-run flag to destructive operations

[UtsavBalar1231]

Problem

Only clean and push commands have --dry-run mode. Other destructive operations lack preview capability, making them risky.

Missing Dry-Run Support

• reset --hard - No preview of what will be reverted
• revert - No preview of changes
• merge - No preview of merge outcome
• checkout - No preview of file changes
• restore - No preview of what will be restored

Impact

• Risky operations without preview
• Users can't verify effects before executing
• Increased chance of accidental data loss
• Poor UX compared to modern tools

Approach

1. Add --dry-run Flag:

#[derive(Parser)]
pub struct ResetArgs {
    #[arg(long)]
    dry_run: bool,
    // ... other args
}

2. Implement Preview Logic:

if args.dry_run {
    // Show what would happen
    println!("Would reset the following files:");
    for file in files_to_reset {
        println!("  {}", file.display());
    }
    println!("\nRun without --dry-run to execute");
    return Ok(());
}

3. Preview Information:

• Files that would be modified
• Files that would be deleted
• Unstaged/uncommitted changes that would be lost
• Commit range that would be affected

4. Consistent Output Format:
Create helper for dry-run output:

fn preview_changes(action: &str, files: &[PathBuf]) {
    println!("{}: {} files would be {}", 
             "Dry run".yellow().bold(), 
             files.len(), 
             action);
    for file in files {
        println!("  {} {}", "→".dim(), file.display());
    }
}

Priority by Command

1. High: reset --hard (most destructive)
2. High: checkout (can overwrite files)
3. Medium: revert, merge (complex operations)
4. Low: restore (usually intentional)

Test Cases

• Each command with --dry-run shows preview
• Verify no actual changes made in dry-run mode
• Verify same logic used for preview and execution

References

• rsync --dry-run as gold standard
• git rm --dry-run, git clean --dry-run
• Consider adding --interactive mode for some commands

[UtsavBalar1231]

Progress Update: --dry-run Implementation

Successfully implemented and tested `--dry-run` flag for high-priority destructive commands.

✅ Completed (Commit 223d764)

Commands with --dry-run support:

1. `reset --hard/--soft/--mixed/--keep`
2. `checkout <branch/commit>`

🧪 Comprehensive Testing Results

All tests passed in isolated `/tmp` environment:

Reset --hard --dry-run:
```
Dry run - would perform hard reset:
→ Commit: 9e73be29
→ 2 file(s) would be restored from snapshot
→ 1 staged change(s) would be cleared
⚠ WARNING: All uncommitted changes would be lost

Run without --dry-run to execute
```

Reset --soft --dry-run:
```
Dry run - would perform soft reset:
→ HEAD would be moved to commit 9e73be29
→ Index and working directory would remain unchanged

Run without --dry-run to execute
```

Checkout --dry-run:
```
Dry run - would checkout:
→ Target: branch 'main'
→ 2 file(s) would be restored
→ Index would be cleared

Run without --dry-run to execute
```

✅ Verification

• No actual changes made in dry-run mode ✓
• File contents preserved ✓
• Staging area unchanged ✓
• Branch state maintained ✓
• Output format consistent with existing `clean` command ✓

📊 Test Coverage

Tested scenarios:

• ✅ Reset with staged changes
• ✅ Checkout between branches
• ✅ All reset modes (hard, soft, mixed, keep)
• ✅ Dry-run messages displayed correctly
• ✅ Warnings for destructive operations

🔄 Remaining Work

Medium priority:

• `revert` - Preview revert changes
• `merge` - Preview merge outcome

Low priority:

• `restore` - Preview file restoration

---

Test script: Comprehensive automated tests verify all dry-run safety guarantees