Puremac Macos Cleaner

// CleanCategory.swiftenum CleanCategory: String, CaseIterable, Identifiable {    case systemJunk       = "System Junk"    case userCache        = "User Cache"    case mailAttachments  = "Mail Attachments"    case trash            = "Trash"    case largeOldFiles    = "Large & Old Files"    case purgeableSpace   = "Purgeable Space"    case xcodeJunk        = "Xcode Junk"    case homebrewCache    = "Homebrew Cache"    // Add your new category here:    case gradleCache      = "Gradle Cache"
    var id: String { rawValue }
    var iconName: String {        switch self {        case .systemJunk:      return "trash.circle"        case .userCache:       return "internaldrive"        case .xcodeJunk:       return "hammer"        case .homebrewCache:   return "shippingbox"        case .gradleCache:     return "archivebox"   // new        default:               return "folder"        }    }}

// ScannerService.swiftfunc scanCategory(_ category: CleanCategory) async throws -> ScanResult {    switch category {    case .gradleCache:        return try await scanPaths([            FileManager.default.homeDirectoryForCurrentUser                .appendingPathComponent(".gradle/caches")        ])    // ...existing cases    default:        throw ScannerError.unsupportedCategory    }}
private func scanPaths(_ urls: [URL]) async throws -> ScanResult {    var files: [ScannedFile] = []    let fm = FileManager.default
    for url in urls {        guard fm.fileExists(atPath: url.path) else { continue }        let enumerator = fm.enumerator(            at: url,            includingPropertiesForKeys: [.fileSizeKey, .contentModificationDateKey],            options: [.skipsHiddenFiles]        )        while let fileURL = enumerator?.nextObject() as? URL {            let values = try fileURL.resourceValues(forKeys: [.fileSizeKey, .contentModificationDateKey])            let size = Int64(values.fileSize ?? 0)            let modified = values.contentModificationDate ?? Date.distantPast            files.append(ScannedFile(url: fileURL, size: size, modifiedDate: modified))        }    }
    let totalBytes = files.reduce(0) { $0 + $1.size }    return ScanResult(category: .gradleCache, files: files, totalBytes: totalBytes)}

// CleanerService.swiftfunc clean(_ result: ScanResult, selectedFiles: Set<URL>? = nil) async throws -> Int64 {    let filesToDelete = selectedFiles.map { Array($0) } ?? result.files.map(\.url)    var bytesFreed: Int64 = 0    let fm = FileManager.default
    for url in filesToDelete {        do {            let attrs = try fm.attributesOfItem(atPath: url.path)            let size = attrs[.size] as? Int64 ?? 0            try fm.removeItem(at: url)            bytesFreed += size        } catch {            // Log but continue — don't abort on single-file failure            print("Failed to delete \(url.lastPathComponent): \(error.localizedDescription)")        }    }    return bytesFreed}

// SchedulerService.swift — how scheduling is implementedimport UserNotifications
class SchedulerService: ObservableObject {    @AppStorage("schedulingEnabled")    var schedulingEnabled: Bool = false    @AppStorage("cleaningInterval")     var cleaningInterval: String = "daily"    @AppStorage("autoCleanAfterScan")   var autoCleanAfterScan: Bool = false    @AppStorage("autoPurgePurgeable")   var autoPurgePurgeable: Bool = false
    private var timer: Timer?
    func scheduleIfNeeded() {        timer?.invalidate()        guard schedulingEnabled else { return }        let interval = intervalSeconds(for: cleaningInterval)        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in            Task { await self?.runScheduledClean() }        }    }
    private func intervalSeconds(for key: String) -> TimeInterval {        switch key {        case "hourly":    return 3_600        case "3h":        return 10_800        case "6h":        return 21_600        case "12h":       return 43_200        case "daily":     return 86_400        case "weekly":    return 604_800        case "biweekly":  return 1_209_600        case "monthly":   return 2_592_000        default:          return 86_400        }    }
    @MainActor    private func runScheduledClean() async {        let scanner = ScannerService()        let cleaner = CleanerService()        for category in CleanCategory.allCases where category != .largeOldFiles {            if let result = try? await scanner.scanCategory(category), autoCleanAfterScan {                _ = try? await cleaner.clean(result)            }        }        if autoPurgePurgeable {            try? await PurgeableService.shared.purge()        }    }}

let scheduler = SchedulerService()scheduler.cleaningInterval = "weekly"scheduler.autoCleanAfterScan = truescheduler.autoPurgePurgeable = falsescheduler.schedulingEnabled = truescheduler.scheduleIfNeeded()

// PurgeableService.swiftimport Foundation
class PurgeableService {    static let shared = PurgeableService()
    func listSnapshots() async throws -> [String] {        let output = try await shell("tmutil listlocalsnapshots /")        return output            .split(separator: "\n")            .map(String.init)            .filter { $0.hasPrefix("com.apple.TimeMachine") }    }
    func purge() async throws {        let snapshots = try await listSnapshots()        for snapshot in snapshots {            try await shell("tmutil deletelocalsnapshots \(snapshot)")        }    }
    @discardableResult    private func shell(_ command: String) async throws -> String {        try await withCheckedThrowingContinuation { continuation in            let task = Process()            task.launchPath = "/bin/bash"            task.arguments = ["-c", command]            let pipe = Pipe()            task.standardOutput = pipe            task.terminationHandler = { _ in                let data = pipe.fileHandleForReading.readDataToEndOfFile()                continuation.resume(returning: String(data: data, encoding: .utf8) ?? "")            }            do { try task.run() } catch { continuation.resume(throwing: error) }        }    }}

// Paths cleaned by the Xcode Junk categorylet home = FileManager.default.homeDirectoryForCurrentUser
let xcodePaths: [URL] = [    home.appendingPathComponent("Library/Developer/Xcode/DerivedData"),    home.appendingPathComponent("Library/Developer/Xcode/Archives"),    home.appendingPathComponent("Library/Developer/CoreSimulator/Caches"),]

// Example: triggering a scan from a SwiftUI viewstruct ScanView: View {    @StateObject private var scanner = ScannerService()    @State private var results: [ScanResult] = []    @State private var isScanning = false
    var body: some View {        VStack {            if isScanning {                ProgressView("Scanning…")            } else {                Button("Smart Scan") {                    Task { await runScan() }                }            }            List(results, id: \.category) { result in                CategoryRow(result: result)            }        }    }
    private func runScan() async {        isScanning = true        results = []        for category in CleanCategory.allCases {            if let result = try? await scanner.scanCategory(category) {                results.append(result)            }        }        isScanning = false    }}

// Show files before deletion — users can deselectstruct CategoryDetailView: View {    let result: ScanResult    @State private var selected: Set<URL> = []    @State private var cleaned = false
    var body: some View {        List(result.files, id: \.url, selection: $selected) { file in            HStack {                Image(systemName: "doc")                Text(file.url.lastPathComponent)                Spacer()                Text(ByteCountFormatter.string(fromByteCount: file.size, countStyle: .file))                    .foregroundStyle(.secondary)            }        }        .toolbar {            Button("Clean Selected") {                Task {                    let cleaner = CleanerService()                    _ = try? await cleaner.clean(result, selectedFiles: selected)                    cleaned = true                }            }            .disabled(selected.isEmpty)        }    }}

UserDefaults.standard.set(true,    forKey: "schedulingEnabled")UserDefaults.standard.set("weekly", forKey: "cleaningInterval")