fix: handle file paths with spaces in git commands (#156)

* Initial plan

* chore: initial investigation of path with spaces issue

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

* fix: handle file paths with spaces in git commands

- Add array-based overloads to ICliWrap interface
- Implement array-based ExecAsync and ExecBufferedAsync in HuskyCliWrap
- Update IGit interface with array-based overloads
- Update Git service to support array arguments
- Fix StagedTask.ReStageFiles to pass file paths as separate arguments
- Remove platform-specific quoting logic (now handled by CliWrap)
- Fix hash-object and update-index commands to use array arguments

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

* fix: remove quotes from verbose logging to match actual execution

Update logging in ReStageFiles to display file paths without quotes,
matching how they are actually passed to git commands.

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

* fix: remove test tasks from task-runner.json to avoid cross-platform issues

Removed the Windows-specific test tasks ('echo staged files' and 'root-dir' variable)
that were causing failures on Linux CI. These tasks used 'cmd' which is not available
on Unix systems. The core fix for path handling with spaces remains intact in the
production code.

* test: add comprehensive tests for path handling with spaces

Added unit tests:
- Test for GetStagedFiles with paths containing spaces
- Test for ExecAsync with array arguments
- Test for ExecBufferedAsync with array arguments

Added integration tests in PathWithSpacesTests.cs:
- Test with single spaces in path
- Test with multiple consecutive spaces
- Test with parentheses and spaces
- Test with mixed special characters
- Test with complex nested directory structure
- Test with multiple files with spaces
- Test with relative path mode

All tests verify that paths with spaces are properly handled without
"fatal: pathspec" errors.

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

* refactor: restore test config with cross-platform commands and use collection expressions

- Restore test variable and task in task-runner.json
- Make test commands cross-platform: use bash/echo instead of cmd
- Update StagedTask to use C# 12 collection expression syntax
- Replace `new List<string> { "add" }; gitAddArgs.AddRange(stagedFiles)` with `["add", ..stagedFiles]`

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

* refactor: improve test config consistency

- Change root-dir variable to use 'pwd' instead of 'ls' to match its purpose
- Rename task to 'echo-staged-files' for consistency with kebab-case naming

Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: alirezanet <7004080+alirezanet@users.noreply.github.com>

Author: Copilot

.husky/commit-msg

@@ -3,8 +3,8 @@
    "variables": [
       {
          "name": "root-dir",
-         "command": "cmd",
-         "args": ["/c", "dir", "/b"]
+         "command": "bash",
+         "args": ["-c", "pwd"]
       }
    ],
    "tasks": [
@@ -19,11 +19,11 @@
          "args" :["husky", "exec", ".husky/csx/version-updater.csx", "--args", "${args}"]
       },
       {
-         "name": "echo staged files",
+         "name": "echo-staged-files",
          "pathMode": "absolute",
-         "command": "cmd",
+         "command": "echo",
          "group": "pre-commit",
-         "args": [ "/c", "echo", "${staged}"]
+         "args": ["${staged}"]
       }
    ]
 }

.husky/task-runner.json

@@ -7,8 +7,10 @@ namespace Husky.Services.Contracts;
 public interface ICliWrap
 {
    Task<BufferedCommandResult> ExecBufferedAsync(string fileName, string args);
+   Task<BufferedCommandResult> ExecBufferedAsync(string fileName, IEnumerable<string> args);
    ValueTask SetExecutablePermission(params string[] files);
    Task<CommandResult> ExecDirectAsync(string fileName, string args);
+   Task<CommandResult> ExecDirectAsync(string fileName, IEnumerable<string> args);
 
    Task<CommandResult> RunCommandAsync(string fileName, IEnumerable<string> args, string cwd,
       OutputTypes output = OutputTypes.Verbose);

src/Husky/Services/Contracts/ICliWrap.cs

@@ -35,5 +35,7 @@ public interface IGit
    /// <returns></returns>
    Task<string[]> GetDiffStagedRecord();
    Task<CommandResult> ExecAsync(string args);
+   Task<CommandResult> ExecAsync(IEnumerable<string> args);
    Task<BufferedCommandResult> ExecBufferedAsync(string args);
+   Task<BufferedCommandResult> ExecBufferedAsync(IEnumerable<string> args);
 }

src/Husky/Services/Contracts/IGit.cs

@@ -185,11 +185,21 @@ public Task<CommandResult> ExecAsync(string args)
       return _cliWrap.ExecDirectAsync("git", args);
    }
 
+   public Task<CommandResult> ExecAsync(IEnumerable<string> args)
+   {
+      return _cliWrap.ExecDirectAsync("git", args);
+   }
+
    public Task<BufferedCommandResult> ExecBufferedAsync(string args)
    {
       return _cliWrap.ExecBufferedAsync("git", args);
    }
 
+   public Task<BufferedCommandResult> ExecBufferedAsync(IEnumerable<string> args)
+   {
+      return _cliWrap.ExecBufferedAsync("git", args);
+   }
+
    private async Task<string> GetHuskyPath()
    {
       try

src/Husky/Services/Git.cs

@@ -26,6 +26,23 @@ public async Task<BufferedCommandResult> ExecBufferedAsync(string fileName, stri
       }
    }
 
+   public async Task<BufferedCommandResult> ExecBufferedAsync(string fileName, IEnumerable<string> args)
+   {
+      try
+      {
+         var result = await CliWrap.Cli
+             .Wrap(fileName)
+             .WithArguments(args)
+             .ExecuteBufferedAsync();
+         return result;
+      }
+      catch (Exception)
+      {
+         $"failed to execute command '{fileName}'".LogErr();
+         throw;
+      }
+   }
+
    public async ValueTask SetExecutablePermission(params string[] files)
    {
       if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -53,6 +70,18 @@ public async Task<CommandResult> ExecDirectAsync(string fileName, string args)
       return result;
    }
 
+   public async Task<CommandResult> ExecDirectAsync(string fileName, IEnumerable<string> args)
+   {
+      var result = await CliWrap.Cli
+          .Wrap(fileName)
+          .WithArguments(args)
+          .WithValidation(CommandResultValidation.None)
+          .WithStandardOutputPipe(PipeTarget.ToDelegate(q => q.Log()))
+          .WithStandardErrorPipe(PipeTarget.ToDelegate(q => q.LogErr()))
+          .ExecuteAsync();
+      return result;
+   }
+
    public async Task<CommandResult> RunCommandAsync(
        string fileName,
        IEnumerable<string> args,

src/Husky/Services/HuskyCliWrap.cs

@@ -1,5 +1,4 @@
 using System.IO.Abstractions;
-using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using CliFx.Exceptions;
 using Husky.Services.Contracts;
@@ -107,7 +106,7 @@ private async Task<double> PartialExecution(List<FileArgumentInfo> partialStaged
       foreach (var tf in tmpFiles)
       {
          // add formatted temp file to git database
-         var result = await _git.ExecBufferedAsync($"hash-object -w {tf.tmp_path}");
+         var result = await _git.ExecBufferedAsync(new[] { "hash-object", "-w", tf.tmp_path });
          var newHash = result.StandardOutput.Trim();
 
          // check if the partial hash exists
@@ -122,7 +121,7 @@ private async Task<double> PartialExecution(List<FileArgumentInfo> partialStaged
          {
             $"Updating index entry for {tf.src_path}".LogVerbose();
             await _git.ExecAsync(
-               $"update-index --cacheinfo {tf.dst_mode},{newHash},{tf.src_path}"
+               new[] { "update-index", "--cacheinfo", $"{tf.dst_mode},{newHash},{tf.src_path}" }
             );
          }
          else
@@ -143,14 +142,17 @@ private async Task ReStageFiles(IEnumerable<FileArgumentInfo> partialStagedFiles
          .OfType<FileArgumentInfo>()
          .Where(q => q.ArgumentTypes == ArgumentTypes.StagedFile)
          .Except(partialStagedFiles)
-         .Select(q => !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? $"\"{q.RelativePath}\"" : $"\"{q.RelativePath.Replace("/", @"\")}\"")
+         .Select(q => q.RelativePath)
          .ToList();
 
       if (stagedFiles.Any())
       {
          "Re-staging staged files...".LogVerbose();
          string.Join(Environment.NewLine, stagedFiles).LogVerbose();
-         await _git.ExecAsync($"add {string.Join(" ", stagedFiles)}");
+         
+         // Build git add command with file paths as separate arguments
+         List<string> gitAddArgs = ["add", ..stagedFiles];
+         await _git.ExecAsync(gitAddArgs);
       }
    }