native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
18 kB · 477 lines
Swift
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478import ComposableArchitectureimport Foundation
extension RepositoriesFeature { // swiftlint:disable:next cyclomatic_complexity function_body_length func reduceRepositoryManagement( state: inout State, action: RepositoryManagementAction ) -> Effect<Action> { switch action { case .openRepositories(let urls): analyticsClient.capture("repository_added", ["count": urls.count]) state.alert = nil return .run { send in let existingEntries = await loadPersistedRepositoryEntries() var resolvedEntries: [PersistedRepositoryEntry] = [] var invalidRoots: [String] = [] var openFailures: [String] = [] for url in urls { let normalizedURL = url.standardizedFileURL if ProjectWorkspace.load(from: normalizedURL) != nil { resolvedEntries.append( PersistedRepositoryEntry( path: normalizedURL.path(percentEncoded: false), kind: .plain ) ) continue } do { let root = try await gitClient.repoRoot(url) resolvedEntries.append( PersistedRepositoryEntry( path: root.path(percentEncoded: false), kind: .git ) ) } catch { let normalizedPath = url.standardizedFileURL.path(percentEncoded: false) if normalizedPath.isEmpty { invalidRoots.append(url.path(percentEncoded: false)) } else if Self.isNotGitRepositoryError(error) { resolvedEntries.append( PersistedRepositoryEntry( path: normalizedPath, kind: .plain ) ) } else { openFailures.append( Self.openRepositoryFailureMessage( path: normalizedPath, error: error ) ) } } } let mergedEntries = RepositoryEntryNormalizer.normalize(existingEntries + resolvedEntries) let mergedRoots = mergedEntries.map { URL(fileURLWithPath: $0.path) } await repositoryPersistence.saveRepositoryEntries(mergedEntries) let (repositories, failures) = await loadRepositoriesData(mergedEntries) await send( .repositoryManagement( .openRepositoriesFinished( repositories, failures: failures, invalidRoots: invalidRoots, openFailures: openFailures, roots: mergedRoots ) ) ) } .cancellable(id: CancelID.load, cancelInFlight: true)
case .openRepositoriesFinished( let repositories, let failures, let invalidRoots, let openFailures, let roots ): state.isRefreshingWorktrees = false let wasRestoringSnapshot = state.snapshotPersistencePhase == .restoring if failures.isEmpty, state.snapshotPersistencePhase != .active { state.snapshotPersistencePhase = .active } let wasAlreadyLoaded = state.isInitialLoadComplete let previousRepoIDs = Set(state.repositories.ids) let previousSelection = state.selectedWorktreeID let previousSelectedWorktree = state.worktree(for: previousSelection) let applyResult = applyRepositories( repositories, roots: roots, shouldPruneArchivedWorktrees: failures.isEmpty, state: &state, animated: false ) state.repositoryRoots = roots state.isInitialLoadComplete = true state.loadFailuresByID = Dictionary( failures.map { ($0.rootID, $0.message) }, uniquingKeysWith: { first, _ in first } ) state.gitUnavailableRepositoryIDs = Set(failures.filter(\.isGitUnavailable).map(\.rootID)) let invalidRootMessages = invalidRoots.map { String(localized: "\($0) is not a Git repository.") } let openFailureMessages = invalidRootMessages + openFailures if !openFailureMessages.isEmpty { state.alert = messageAlert( title: String(localized: "Some folders couldn't be opened"), message: openFailureMessages.joined(separator: "\n") ) } let selectedWorktree = state.worktree(for: state.selectedWorktreeID) let selectionChanged = selectionDidChange( previousSelectionID: previousSelection, previousSelectedWorktree: previousSelectedWorktree, selectedWorktreeID: state.selectedWorktreeID, selectedWorktree: selectedWorktree ) var allEffects: [Effect<Action>] = [ .send(.delegate(.repositoriesChanged(state.repositories))) ] if selectionChanged { allEffects.append(.send(.delegate(.selectedWorktreeChanged(selectedWorktree)))) } if applyResult.didPrunePinned { let pinnedWorktreeIDs = state.pinnedWorktreeIDs allEffects.append( .run { _ in await repositoryPersistence.savePinnedWorktreeIDs(pinnedWorktreeIDs) }) } if applyResult.didPruneRepositoryOrder { let repositoryOrderIDs = state.repositoryOrderIDs allEffects.append( .run { _ in await repositoryPersistence.saveRepositoryOrderIDs(repositoryOrderIDs) }) } if applyResult.didPruneWorktreeOrder { let worktreeOrderByRepository = state.worktreeOrderByRepository allEffects.append( .run { _ in await repositoryPersistence.saveWorktreeOrderByRepository(worktreeOrderByRepository) }) } if applyResult.didPruneArchivedWorktrees { let archivedWorktrees = state.archivedWorktrees allEffects.append( .run { _ in await repositoryPersistence.saveArchivedWorktrees(archivedWorktrees) } ) } if failures.isEmpty, !wasRestoringSnapshot { let repositories = Array(state.repositories) allEffects.append( .run { _ in await repositoryPersistence.saveRepositorySnapshot(repositories) } ) } if let effect = detectCodeHostsEffect(for: state.repositories) { allEffects.append(effect) } allEffects.append(refreshWorkspaceChildrenEffect(state: state)) if wasAlreadyLoaded, !wasRestoringSnapshot { let newRepos = state.repositories.filter { !previousRepoIDs.contains($0.id) } if let firstNew = newRepos.first { if let worktreeID = firstNew.worktrees.first?.id { allEffects.append(.send(.selectWorktree(worktreeID, focusTerminal: true))) } else if firstNew.capabilities.supportsRunnableFolderActions { state.pendingTerminalFocusWorktreeIDs.insert(firstNew.id) allEffects.append(.send(.selectRepository(firstNew.id))) } } allEffects.append(contentsOf: iconDetectionEffects(for: Array(newRepos))) } return .merge(allEffects)
case .requestRemoveRepository(let repositoryID): if let repository = state.repositories[id: repositoryID], repository.isWorkspace { let branchOptions = (repository.workspace?.repositories ?? []).compactMap { entry -> RemoveWorkspaceConfirmation.BranchOption? in guard entry.sourceKind != .remote, let branchName = entry.branchName, entry.sourceLocation != nil else { return nil } return RemoveWorkspaceConfirmation.BranchOption( id: entry.id, repositoryName: entry.name, branchName: branchName ) } state.removeWorkspaceConfirmation = RemoveWorkspaceConfirmation( repositoryID: repositoryID, workspaceTitle: repository.name, rootPath: repository.rootURL.path(percentEncoded: false), branchOptions: branchOptions ) return .none } state.alert = confirmationAlertForRepositoryRemoval(repositoryID: repositoryID, state: state) return .none
case .removeWorkspaceDeleteFilesChanged(let deleteFiles): state.removeWorkspaceConfirmation?.deleteFiles = deleteFiles return .none
case .removeWorkspaceDeleteBranchChanged(let entryID, let isSelected): guard var confirmation = state.removeWorkspaceConfirmation, let index = confirmation.branchOptions.firstIndex(where: { $0.id == entryID }) else { return .none } confirmation.branchOptions[index].isSelected = isSelected state.removeWorkspaceConfirmation = confirmation return .none
case .removeWorkspacePromptDismissed: state.removeWorkspaceConfirmation = nil return .none
case .removeWorkspacePromptConfirmed: guard let confirmation = state.removeWorkspaceConfirmation else { return .none } state.removeWorkspaceConfirmation = nil guard let repository = state.repositories[id: confirmation.repositoryID], !state.removingRepositoryIDs.contains(repository.id) else { return .none } state.removingRepositoryIDs.insert(repository.id) let selectionWasRemoved = state.selection == .repository(repository.id) || (state.selectedWorktreeID.map { id in repository.worktrees.contains(where: { $0.id == id }) } ?? false) guard confirmation.deleteFiles, let workspace = repository.workspace else { return .send( .repositoryManagement( .repositoryRemoved(repository.id, selectionWasRemoved: selectionWasRemoved) ) ) } let repositoryID = repository.id let rootURL = repository.rootURL // Resolve the (source repo, branch) pairs the user opted to delete. The // deletion itself is routed through GitClient's guarded entry point so a // protected branch (main/master/default) can never be force-deleted. let branchDeletions: [WorkspaceBranchDeletion] = confirmation.branchOptions .filter(\.isSelected) .compactMap { option in guard let entry = workspace.repositories.first(where: { $0.id == option.id }), let sourceLocation = entry.sourceLocation, let branchName = entry.branchName else { return nil } return WorkspaceBranchDeletion(sourceLocation: sourceLocation, branchName: branchName) } let gitRunner = Self.workspaceGitRunner(shellClient: shellClient) let gitClient = self.gitClient return .run { send in let failedRepositoryNames = await ProjectWorkspace.removeWorktrees( workspace, rootURL: rootURL, gitRunner: gitRunner ) for deletion in branchDeletions { let outcome = try? await gitClient.deleteLocalBranch( deletion.branchName, URL(fileURLWithPath: deletion.sourceLocation), true ) if case .protected? = outcome { workspaceRemovalLog.warning( "Skipped deleting protected branch \(deletion.branchName) in \(deletion.sourceLocation)" ) } } // Only delete the workspace folder when every worktree was unregistered; // otherwise ask the user, since deleting it would orphan a live worktree // registration in the source repository. if failedRepositoryNames.isEmpty { ProjectWorkspace.removeWorkspaceFolder(at: rootURL) await send( .repositoryManagement( .repositoryRemoved(repositoryID, selectionWasRemoved: selectionWasRemoved) ) ) } else { await send( .repositoryManagement( .workspaceCleanupReportedFailures( repositoryID: repositoryID, rootPath: rootURL.path(percentEncoded: false), failedRepositoryNames: failedRepositoryNames, selectionWasRemoved: selectionWasRemoved ) ) ) } }
case .workspaceCleanupReportedFailures( let repositoryID, let rootPath, let failedRepositoryNames, let selectionWasRemoved ): state.alert = workspaceCleanupFailureAlert( repositoryID: repositoryID, rootPath: rootPath, failedRepositoryNames: failedRepositoryNames, selectionWasRemoved: selectionWasRemoved ) return .none
case .removeFailedRepository(let repositoryID): state.alert = nil state.loadFailuresByID.removeValue(forKey: repositoryID) state.gitUnavailableRepositoryIDs.remove(repositoryID) state.repositoryRoots.removeAll { isSameRepositoryPath($0.standardizedFileURL.path(percentEncoded: false), repositoryID) } let failedIconCleanup = iconDetectionRemovalEffect( repositoryID: repositoryID, rootURL: state.repositories[id: repositoryID]?.rootURL ) let remainingRoots = state.repositoryRoots return .merge( failedIconCleanup, // Failed roots are absent from the loaded models, so a reload may not emit this delegate. .send(.delegate(.repositoriesChanged(state.repositories))), .run { send in let loadedEntries = await loadPersistedRepositoryEntries(fallbackRoots: remainingRoots) let remainingEntries = loadedEntries.filter { !isSameRepositoryPath($0.path, repositoryID) } await repositoryPersistence.saveRepositoryEntries(remainingEntries) let roots = remainingEntries.map { URL(fileURLWithPath: $0.path) } let (repositories, failures) = await loadRepositoriesData(remainingEntries) await send( .repositoriesLoaded( repositories, failures: failures, roots: roots, animated: true ) ) } .cancellable(id: CancelID.load, cancelInFlight: true) )
case .repositoryRemoved(let repositoryID, let selectionWasRemoved): analyticsClient.capture("repository_removed", [String: Any]?.none) state.removingRepositoryIDs.remove(repositoryID) if selectionWasRemoved { state.selection = nil state.selectedWorkspaceChildID = nil state.shouldSelectFirstAfterReload = true } let iconCleanup = iconDetectionRemovalEffect( repositoryID: repositoryID, rootURL: state.repositories[id: repositoryID]?.rootURL ) let selectedWorktree = state.worktree(for: state.selectedWorktreeID) let remainingRoots = state.repositoryRoots return .merge( iconCleanup, .send(.delegate(.selectedWorktreeChanged(selectedWorktree))), .run { send in let loadedEntries = await loadPersistedRepositoryEntries(fallbackRoots: remainingRoots) let remainingEntries = loadedEntries.filter { !isSameRepositoryPath($0.path, repositoryID) } await repositoryPersistence.saveRepositoryEntries(remainingEntries) let roots = remainingEntries.map { URL(fileURLWithPath: $0.path) } let (repositories, failures) = await loadRepositoriesData(remainingEntries) await send( .repositoriesLoaded( repositories, failures: failures, roots: roots, animated: true ) ) } .cancellable(id: CancelID.load, cancelInFlight: true) )
case .openRepositorySettings(let repositoryID): return .send(.delegate(.openRepositorySettings(repositoryID)))
case .repositoryIconDetected(let repositoryID, let filename): return reduceIconDetected(state: &state, repositoryID: repositoryID, filename: filename)
case .cancelPendingIconDetections: return .cancel(id: Self.iconDetectionUmbrellaID) } }
var repositoryManagementReducer: some ReducerOf<Self> { Reduce { state, action in guard case .repositoryManagement(let action) = action else { return .none } return reduceRepositoryManagement(state: &state, action: action) } }
func workspaceCleanupFailureAlert( repositoryID: Repository.ID, rootPath: String, failedRepositoryNames: [String], selectionWasRemoved: Bool ) -> AlertState<Alert> { AlertState { TextState(String(localized: "Some worktrees couldn't be removed")) } actions: { ButtonState( role: .destructive, action: .confirmWorkspaceRootDeletion( repositoryID: repositoryID, rootPath: rootPath, selectionWasRemoved: selectionWasRemoved ) ) { TextState(String(localized: "Delete Folder Anyway")) } ButtonState( role: .cancel, action: .keepWorkspaceFolderAfterCleanupFailure( repositoryID: repositoryID, selectionWasRemoved: selectionWasRemoved ) ) { TextState(String(localized: "Keep Folder")) } } message: { TextState( String( localized: """ Couldn't unregister worktrees for \(failedRepositoryNames.joined(separator: ", ")). \ Deleting the workspace folder now would leave those worktrees registered in their source \ repositories. Delete it anyway? """ ) ) } }}
nonisolated private let workspaceRemovalLog = ProwlLogger("workspace")
nonisolated struct WorkspaceBranchDeletion: Sendable, Equatable { let sourceLocation: String let branchName: String}
// Path-based URL APIs append a trailing slash only while the directory exists// on disk, so an ID captured before a deletion may not equal the re-normalized// entry path afterwards.nonisolated private func isSameRepositoryPath(_ lhs: String, _ rhs: String) -> Bool { comparableRepositoryPath(lhs) == comparableRepositoryPath(rhs)}
nonisolated private func comparableRepositoryPath(_ path: String) -> String { var path = path while path.count > 1, path.hasSuffix("/") { path.removeLast() } return path}