Allow purge-cache to run without Package.swift

Sources/Commands/PackageCommands/ResetCommands.swift

@@ -35,7 +35,7 @@ extension SwiftPackageCommand {
  var globalOptions: GlobalOptions
 
  func run(_ swiftCommandState: SwiftCommandState) async throws {
- try await swiftCommandState.getActiveWorkspace().purgeCache(observabilityScope: swiftCommandState.observabilityScope)
+ try await swiftCommandState.purgeCaches(observabilityScope: swiftCommandState.observabilityScope)
  }
  }
 

Sources/CoreCommands/SwiftCommandState.swift

@@ -16,10 +16,14 @@ import Basics
 import Dispatch
 import class Foundation.NSLock
 import class Foundation.ProcessInfo
+import PackageFingerprint
 import PackageGraph
 import PackageLoading
 @_spi(SwiftPMInternal)
 import PackageModel
+import PackageRegistry
+import PackageSigning
+import SourceControl
 import SPMBuildCore
 import Workspace
 
@@ -50,6 +54,7 @@ import class TSCBasic.FileLock
 import enum TSCBasic.JSON
 import protocol TSCBasic.OutputByteStream
 import enum TSCBasic.ProcessEnv
+import struct TSCBasic.SHA256
 import enum TSCBasic.ProcessLockError
 import var TSCBasic.stderrStream
 import class TSCBasic.TerminalController
@@ -534,6 +539,55 @@ public final class SwiftCommandState {
  return workspace
  }
 
+ /// Purges all global caches without requiring workspace initialization.
+ /// This method creates minimal cache managers directly and calls their purgeCache methods.
+ public func purgeCaches(observabilityScope: ObservabilityScope) async throws {
+ // Create repository manager for repository cache
+ let repositoryManager = RepositoryManager(
+ fileSystem: self.fileSystem,
+ path: self.scratchDirectory.appending("repositories"),
+ provider: GitRepositoryProvider(),
+ cachePath: self.sharedCacheDirectory.appending("repositories"),
+ initializationWarningHandler: { observabilityScope.emit(warning: $0) },
+ delegate: nil
+ )
+
+ // Create manifest loader for manifest cache
+ let manifestLoader = ManifestLoader(
+ toolchain: try self.getHostToolchain(),
+ cacheDir: Workspace.DefaultLocations.manifestsDirectory(at: self.sharedCacheDirectory),
+ importRestrictions: nil,
+ delegate: nil,
+ pruneDependencies: false
+ )
+
+ // Create registry downloads manager for registry cache
+ let registryClient = RegistryClient(
+ configuration: .init(),
+ fingerprintStorage: nil,
+ fingerprintCheckingMode: .strict,
+ skipSignatureValidation: false,
+ signingEntityStorage: nil,
+ signingEntityCheckingMode: .strict,
+ authorizationProvider: nil,
+ delegate: nil,
+ checksumAlgorithm: SHA256()
+ )
+
+ let registryDownloadsManager = RegistryDownloadsManager(
+ fileSystem: self.fileSystem,
+ path: self.scratchDirectory.appending(components: "registry", "downloads"),
+ cachePath: self.sharedCacheDirectory.appending(components: "registry", "downloads"),
+ registryClient: registryClient,
+ delegate: nil
+ )
+
+ // Purge all caches
+ repositoryManager.purgeCache(observabilityScope: observabilityScope)
+ registryDownloadsManager.purgeCache(observabilityScope: observabilityScope)
+ await manifestLoader.purgeCache(observabilityScope: observabilityScope)
+ }
+
  public func getRootPackageInformation(_ enableAllTraits: Bool = false) async throws -> (dependencies: [PackageIdentity: [PackageIdentity]], targets: [PackageIdentity: [String]]) {
  let workspace = try self.getActiveWorkspace(enableAllTraits: enableAllTraits)
  let root = try self.getWorkspaceRoot()

Sources/PackageLoading/ManifestLoader.swift

@@ -999,6 +999,8 @@ public final class ManifestLoader: ManifestLoaderProtocol {
  return
  }
 
+ observabilityScope.emit(info: "Purging manifest cache at '\(manifestCacheDBPath)'")
+
  do {
  try localFileSystem.removeFileTree(manifestCacheDBPath)
  } catch {

Sources/PackageRegistry/RegistryDownloadsManager.swift

@@ -275,6 +275,8 @@ public class RegistryDownloadsManager: AsyncCancellable {
  return
  }
 
+ observabilityScope.emit(info: "Purging registry cache at '\(cachePath)'")
+
  do {
  try self.fileSystem.withLock(on: cachePath, type: .exclusive) {
  let cachedPackages = try self.fileSystem.getDirectoryContents(cachePath)

Sources/SourceControl/RepositoryManager.swift

@@ -470,6 +470,8 @@ public class RepositoryManager: Cancellable {
  return
  }
 
+ observabilityScope.emit(info: "Purging repository cache at '\(cachePath)'")
+
  do {
  try self.fileSystem.withLock(on: cachePath, type: .exclusive) {
  let cachedRepositories = try self.fileSystem.getDirectoryContents(cachePath)

Sources/Workspace/Workspace.swift

@@ -907,16 +907,6 @@ extension Workspace {
  }
  }
 
- /// Cleans the build artifacts from workspace data.
- ///
- /// - Parameters:
- /// - observabilityScope: The observability scope that reports errors, warnings, etc
- public func purgeCache(observabilityScope: ObservabilityScope) async {
- self.repositoryManager.purgeCache(observabilityScope: observabilityScope)
- self.registryDownloadsManager.purgeCache(observabilityScope: observabilityScope)
- await self.manifestLoader.purgeCache(observabilityScope: observabilityScope)
- }
-
  /// Resets the entire workspace by removing the data directory.
  ///
  /// - Parameters:

Sources/_InternalTestSupport/SwiftTesting+Tags.swift

@@ -68,6 +68,7 @@ extension Tag.Feature.Command.Package {
  @Tag public static var Migrate: Tag
  @Tag public static var Plugin: Tag
  @Tag public static var Reset: Tag
+ @Tag public static var PurgeCache: Tag
  @Tag public static var Resolve: Tag
  @Tag public static var ShowDependencies: Tag
  @Tag public static var ShowExecutables: Tag

Tests/CommandsTests/PackageCommandTests.swift

@@ -2935,6 +2935,93 @@ struct PackageCommandTests {
  }
  }
 
+ @Test(
+ .tags(.Feature.Command.Package.PurgeCache),
+ arguments: getBuildData(for: SupportedBuildSystemOnAllPlatforms),
+ )
+ func purgeCacheWithoutPackage(
+ data: BuildData,
+ ) async throws {
+ // Create a temporary directory without Package.swift
+ try await fixture(name: "Miscellaneous") { fixturePath in
+ let tempDir = fixturePath.appending("empty-dir-for-purge-test")
+ try localFileSystem.createDirectory(tempDir, recursive: true)
+
+ // Use a unique temporary cache directory to avoid conflicts with parallel tests
+ try await withTemporaryDirectory(removeTreeOnDeinit: true) { cacheDir in
+ let result = try await executeSwiftPackage(
+ tempDir,
+ configuration: data.config,
+ extraArgs: ["purge-cache", "--cache-path", cacheDir.pathString],
+ buildSystem: data.buildSystem
+ )
+
+ #expect(!result.stderr.contains("Could not find Package.swift"))
+ }
+ }
+ }
+
+ @Test(
+ .tags(.Feature.Command.Package.PurgeCache),
+ arguments: getBuildData(for: SupportedBuildSystemOnAllPlatforms),
+ )
+ func purgeCacheInPackageDirectory(
+ data: BuildData,
+ ) async throws {
+ // Test that purge-cache works in a package directory and successfully purges caches
+ try await fixture(name: "DependencyResolution/External/Simple") { fixturePath in
+ let packageRoot = fixturePath.appending("Bar")
+
+ // Use a unique temporary cache directory for this test
+ try await withTemporaryDirectory(removeTreeOnDeinit: true) { tempDir in
+ let cacheDir = tempDir.appending("test-cache")
+ let cacheArgs = ["--cache-path", cacheDir.pathString]
+
+ // Resolve dependencies to populate cache
+ // Note: This fixture uses local dependencies, so only manifest cache will be populated
+ try await executeSwiftPackage(
+ packageRoot,
+ configuration: data.config,
+ extraArgs: ["resolve"] + cacheArgs,
+ buildSystem: data.buildSystem
+ )
+
+ // Verify manifest cache was populated
+ let manifestsCache = cacheDir.appending(components: "manifests")
+ expectDirectoryExists(at: manifestsCache)
+
+ // Check for manifest.db file (main database file)
+ let manifestDB = manifestsCache.appending("manifest.db")
+ let hasManifestDB = localFileSystem.exists(manifestDB)
+
+ // Check for SQLite auxiliary files that might exist
+ let manifestDBWAL = manifestsCache.appending("manifest.db-wal")
+ let manifestDBSHM = manifestsCache.appending("manifest.db-shm")
+ let hasAuxFiles = localFileSystem.exists(manifestDBWAL) || localFileSystem.exists(manifestDBSHM)
+
+ // At least one manifest database file should exist
+ #expect(hasManifestDB || hasAuxFiles, "Manifest cache should be populated after resolve")
+
+ // Run purge-cache
+ let result = try await executeSwiftPackage(
+ packageRoot,
+ configuration: data.config,
+ extraArgs: ["purge-cache"] + cacheArgs,
+ buildSystem: data.buildSystem
+ )
+
+ // Verify command succeeded
+ #expect(!result.stderr.contains("Could not find Package.swift"))
+
+ // Verify manifest.db was removed (the purge implementation removes this file)
+ expectFileDoesNotExists(at: manifestDB, "manifest.db should be removed after purge")
+
+ // Note: SQLite auxiliary files (WAL/SHM) may or may not be removed depending on SQLite state
+ // The important check is that the main database file is removed
+ }
+ }
+ }
+
  @Test(
  .tags(
  .Feature.Command.Package.Resolve,