feat: Add parallel directory processing for faster formatting

Process multiple directories concurrently using Swift's TaskGroup,
where each directory runs its full formatting pipeline independently:
SwiftFormat → SwiftLint autocorrect → SwiftLint lint.

## Changes

- Convert AirbnbSwiftFormatTool to AsyncParsableCommand
- Add Command.runAsync() using Task.detached for true parallelism
- Add DirectoryResult struct for per-directory exit code aggregation
- Use withTaskGroup (not withThrowingTaskGroup) to process ALL directories
  even when some fail, giving users complete feedback
- Add directory context to error messages (e.g., "Lint failures in: DirA, DirC")
- Update tests to support async execution
- Add tests for mixed success/failure scenarios across directories
- Update ArgumentParser to 1.7.0 for AsyncParsableCommand support
- Update minimum macOS to 10.15 for Swift Concurrency

## Benchmark Results (IronUI - 141 files, 3 directories)

| Version    | Wall-clock Time | Speedup      |
|------------|-----------------|--------------|
| Sequential | 1.494s          | baseline     |
| Parallel   | 0.686s          | 2.18x faster |

Author: Iron-Ham

Package.resolved

@@ -3,12 +3,12 @@ import PackageDescription
 
 let package = Package(
   name: "AirbnbSwift",
-  platforms: [.macOS(.v10_13)],
+  platforms: [.macOS(.v10_15)],
   products: [
     .plugin(name: "FormatSwift", targets: ["FormatSwift"])
   ],
   dependencies: [
-    .package(url: "https://github.com/apple/swift-argument-parser", from: "1.0.3")
+    .package(url: "https://github.com/apple/swift-argument-parser", from: "1.7.0")
   ],
   targets: [
     .plugin(

Package.swift

@@ -6,7 +6,7 @@ import Foundation
 /// A command line tool that formats the given directories using SwiftFormat and SwiftLint,
 /// based on the Airbnb Swift Style Guide
 @main
-struct AirbnbSwiftFormatTool: ParsableCommand {
+struct AirbnbSwiftFormatTool: AsyncParsableCommand {
 
   // MARK: Internal
 
@@ -40,64 +40,134 @@ struct AirbnbSwiftFormatTool: ParsableCommand {
   @Option(help: "The project's minimum Swift version")
   var swiftVersion: String?
 
-  func run() throws {
-    let swiftFormat = makeSwiftFormatCommand()
-    let swiftLint = makeSwiftLintCommand(autocorrect: false)
-    let swiftLintAutocorrect = makeSwiftLintCommand(autocorrect: true)
+  func run() async throws {
+    // Process all directories in parallel, each running the full pipeline independently.
+    // We use withTaskGroup (not withThrowingTaskGroup) to ensure ALL directories are processed
+    // even if some fail - this gives users complete feedback about all issues.
+    let results = await withTaskGroup(of: Result<DirectoryResult, Error>.self) { group in
+      for directory in directories {
+        group.addTask {
+          do {
+            return .success(try await processDirectory(directory))
+          } catch {
+            return .failure(DirectoryError(directory: directory, underlyingError: error))
+          }
+        }
+      }
+
+      var results = [Result<DirectoryResult, Error>]()
+      for await result in group {
+        results.append(result)
+      }
+      return results
+    }
+
+    try aggregateResults(results)
+  }
 
-    let swiftFormatExitCode = try swiftFormat.run()
+  // MARK: Private
+
+  /// Whether the command should autocorrect invalid code, or only emit lint errors
+  private var lintOnly: Bool {
+    lint
+  }
+
+  /// Processes a single directory through the full formatting pipeline
+  ///  - SwiftFormat -> SwiftLint autocorrect (if not lint-only) -> SwiftLint lint
+  private func processDirectory(_ directory: String) async throws -> DirectoryResult {
+    let swiftFormatExitCode = try await makeSwiftFormatCommand(for: directory).runAsync()
 
     // Run SwiftLint in autocorrect mode first, so that if autocorrect fixes all of the SwiftLint violations
     // then the following lint-only invocation will not report any violations.
     let swiftLintAutocorrectExitCode: Int32?
-    if
-      // When only linting, we shouldn't run SwiftLint with autocorrect enabled
-      !lintOnly
-    {
-      swiftLintAutocorrectExitCode = try swiftLintAutocorrect.run()
+    if !lintOnly {
+      swiftLintAutocorrectExitCode = try await makeSwiftLintCommand(for: directory, autocorrect: true).runAsync()
     } else {
       swiftLintAutocorrectExitCode = nil
     }
 
     // We always have to run SwiftLint in lint-only mode at least once,
     // because when in autocorrect mode SwiftLint won't emit any lint warnings.
-    let swiftLintExitCode = try swiftLint.run()
+    let swiftLintExitCode = try await makeSwiftLintCommand(for: directory, autocorrect: false).runAsync()
 
-    if
-      swiftFormatExitCode == SwiftFormatExitCode.lintFailure ||
-      swiftLintExitCode == SwiftLintExitCode.lintFailure ||
-      swiftLintAutocorrectExitCode == SwiftLintExitCode.lintFailure
-    {
-      throw ExitCode.failure
-    }
+    return DirectoryResult(
+      directory: directory,
+      swiftFormatExitCode: swiftFormatExitCode,
+      swiftLintExitCode: swiftLintExitCode,
+      swiftLintAutocorrectExitCode: swiftLintAutocorrectExitCode
+    )
+  }
 
-    // Any other non-success exit code is an unknown failure
-    if swiftFormatExitCode != EXIT_SUCCESS {
-      throw ExitCode(swiftFormatExitCode)
+  /// Aggregates results from all directories and throws appropriate errors
+  private func aggregateResults(_ results: [Result<DirectoryResult, Error>]) throws {
+    var successResults = [DirectoryResult]()
+    var executionErrors = [DirectoryError]()
+
+    // Separate successes from execution errors
+    for result in results {
+      switch result {
+      case .success(let directoryResult):
+        successResults.append(directoryResult)
+      case .failure(let error):
+        if let directoryError = error as? DirectoryError {
+          executionErrors.append(directoryError)
+        } else {
+          // Defensive: wrap unexpected error types to avoid silent failures
+          executionErrors.append(DirectoryError(directory: "unknown", underlyingError: error))
+        }
+      }
     }
 
-    if swiftLintExitCode != EXIT_SUCCESS {
-      throw ExitCode(swiftLintExitCode)
+    // Report any execution errors (e.g., binary not found)
+    if let firstError = executionErrors.first {
+      for error in executionErrors {
+        log("Failed to process '\(error.directory)': \(error.underlyingError.localizedDescription)")
+      }
+      throw firstError.underlyingError
     }
 
-    if
-      let swiftLintAutocorrectExitCode = swiftLintAutocorrectExitCode,
-      swiftLintAutocorrectExitCode != EXIT_SUCCESS
-    {
-      throw ExitCode(swiftLintAutocorrectExitCode)
+    // Check for lint failures and report which directories had issues
+    var directoriesWithLintFailures = [String]()
+    for result in successResults {
+      if
+        result.swiftFormatExitCode == SwiftFormatExitCode.lintFailure ||
+        result.swiftLintExitCode == SwiftLintExitCode.lintFailure ||
+        result.swiftLintAutocorrectExitCode == SwiftLintExitCode.lintFailure
+      {
+        directoriesWithLintFailures.append(result.directory)
+      }
     }
-  }
 
-  // MARK: Private
+    if !directoriesWithLintFailures.isEmpty {
+      log("Lint failures in: \(directoriesWithLintFailures.joined(separator: ", "))")
+      throw ExitCode.failure
+    }
 
-  /// Whether the command should autocorrect invalid code, or only emit lint errors
-  private var lintOnly: Bool {
-    lint
+    // Any other non-success exit code is an unknown failure
+    for result in successResults {
+      if result.swiftFormatExitCode != EXIT_SUCCESS {
+        log("SwiftFormat failed in '\(result.directory)' with exit code \(result.swiftFormatExitCode)")
+        throw ExitCode(result.swiftFormatExitCode)
+      }
+
+      if result.swiftLintExitCode != EXIT_SUCCESS {
+        log("SwiftLint failed in '\(result.directory)' with exit code \(result.swiftLintExitCode)")
+        throw ExitCode(result.swiftLintExitCode)
+      }
+
+      if
+        let swiftLintAutocorrectExitCode = result.swiftLintAutocorrectExitCode,
+        swiftLintAutocorrectExitCode != EXIT_SUCCESS
+      {
+        log("SwiftLint autocorrect failed in '\(result.directory)' with exit code \(swiftLintAutocorrectExitCode)")
+        throw ExitCode(swiftLintAutocorrectExitCode)
+      }
+    }
   }
 
-  /// Builds a command that runs the SwiftFormat tool
-  private func makeSwiftFormatCommand() -> Command {
-    var arguments = directories + [
+  /// Builds a command that runs the SwiftFormat tool on a single directory
+  private func makeSwiftFormatCommand(for directory: String) -> Command {
+    var arguments = [directory] + [
       "--config",
       swiftFormatConfig,
     ]
@@ -121,11 +191,11 @@ struct AirbnbSwiftFormatTool: ParsableCommand {
     )
   }
 
-  /// Builds a command that runs the SwiftLint tool
+  /// Builds a command that runs the SwiftLint tool on a single directory
   ///  - If `autocorrect` is true, passes the `--fix` flag to SwiftLint.
   ///    When autocorrecting, SwiftLint doesn't emit any lint warnings.
-  private func makeSwiftLintCommand(autocorrect: Bool) -> Command {
-    var arguments = directories + [
+  private func makeSwiftLintCommand(for directory: String, autocorrect: Bool) -> Command {
+    var arguments = [directory] + [
       "--config",
       swiftLintConfig,
       // Required for SwiftLint to emit a non-zero exit code on lint failure
@@ -175,3 +245,21 @@ enum SwiftFormatExitCode {
 enum SwiftLintExitCode {
   static let lintFailure: Int32 = 2
 }
+
+// MARK: - DirectoryResult
+
+/// The result of running the formatting pipeline on a single directory
+struct DirectoryResult: Sendable {
+  let directory: String
+  let swiftFormatExitCode: Int32
+  let swiftLintExitCode: Int32
+  let swiftLintAutocorrectExitCode: Int32?
+}
+
+// MARK: - DirectoryError
+
+/// An error that occurred while processing a specific directory
+struct DirectoryError: Error {
+  let directory: String
+  let underlyingError: Error
+}

Sources/AirbnbSwiftFormatTool/AirbnbSwiftFormatTool.swift

@@ -21,6 +21,15 @@ struct Command {
     try Command.runCommand(self)
   }
 
+  /// Async variant that runs the command in a detached background Task
+  ///  - Uses Task.detached to ensure true parallel execution on background threads
+  ///  - Enables concurrent processing of multiple commands without serialization
+  func runAsync() async throws -> Int32 {
+    try await Task.detached {
+      try run()
+    }.value
+  }
+
   // MARK: Private
 
   /// Synchronously runs this command and returns its exit code