native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
13 kB · 425 lines
Swift
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426import ComposableArchitectureimport Foundation
func queuePullRequestRefresh( repositoryID: Repository.ID, repositoryRootURL: URL, worktreeIDs: [Worktree.ID], refreshesByRepositoryID: inout [Repository.ID: RepositoriesFeature.PendingPullRequestRefresh]) { if var pending = refreshesByRepositoryID[repositoryID] { var seenWorktreeIDs = Set(pending.worktreeIDs) for worktreeID in worktreeIDs where seenWorktreeIDs.insert(worktreeID).inserted { pending.worktreeIDs.append(worktreeID) } refreshesByRepositoryID[repositoryID] = pending } else { refreshesByRepositoryID[repositoryID] = RepositoriesFeature.PendingPullRequestRefresh( repositoryRootURL: repositoryRootURL, worktreeIDs: worktreeIDs ) }}
func reorderedUnpinnedWorktreeIDs( for worktreeID: Worktree.ID, in repository: Repository, state: RepositoriesFeature.State) -> [Worktree.ID] { var ordered = state.orderedUnpinnedWorktreeIDs(in: repository) guard let index = ordered.firstIndex(of: worktreeID) else { return ordered } ordered.remove(at: index) ordered.insert(worktreeID, at: 0) return ordered}
func restoreSelection( _ id: Worktree.ID?, pendingID: Worktree.ID, state: inout RepositoriesFeature.State) { guard state.selection == .worktree(pendingID) else { return } setSingleWorktreeSelection( isSelectionValid(id, state: state) ? id : nil, state: &state, recordHistory: false ) pruneWorktreeHistoryTails(state: &state)}
func isSelectionValid( _ id: Worktree.ID?, state: RepositoriesFeature.State) -> Bool { state.selectedRow(for: id) != nil}
/// Choose the next book to open after `worktreeID`'s book is retired./// Prefer the book immediately *after* the closed one in Shelf order;/// fall back to the one immediately *before* it; return `nil` when/// Shelf is inactive, when the closed book isn't the currently open/// one, or when no other books remain.func replacementBookAfterClosing( worktreeID: Worktree.ID, state: RepositoriesFeature.State) -> ShelfBook? { guard state.isShelfActive, state.selectedTerminalWorktree?.id == worktreeID else { return nil } let books = state.orderedShelfBooks() guard let index = books.firstIndex(where: { $0.id == worktreeID }) else { return nil } let remaining = books.enumerated().filter { $0.offset != index }.map(\.element) guard !remaining.isEmpty else { return nil } // After removing index `index`, the "next" book is now at position // `index` in the reduced list (if it exists); otherwise the last one // is the "previous" relative to what was closed. if index < remaining.count { return remaining[index] } return remaining.last}
/// Returns the Shelf book at `offset` positions from the currently open/// book (wrapping around the book list). Returns nil if there are no/// books. When there is no open book, offset > 0 picks the first book/// and offset < 0 picks the last.func shelfBook( atOffset offset: Int, state: RepositoriesFeature.State) -> ShelfBook? { let books = state.orderedShelfBooks() guard !books.isEmpty else { return nil } if let currentID = state.openShelfBookID, let currentIndex = books.firstIndex(where: { $0.id == currentID }) { let nextIndex = (currentIndex + offset + books.count) % books.count return books[nextIndex] } return offset > 0 ? books.first : books.last}
/// Dispatches the right selection action for a book — a worktree vs./// a plain folder requires different Reducer actions even though the/// Shelf treats them uniformly.func shelfBookSelectionEffect( for book: ShelfBook) -> Effect<RepositoriesFeature.Action> { switch book.kind { case .worktree: return .send(.selectWorktree(book.id, focusTerminal: true, recordHistory: false)) case .plainFolder: return .send(.selectRepository(book.repositoryID)) }}
func isSidebarSelectionValid( _ selection: SidebarSelection?, state: RepositoriesFeature.State) -> Bool { switch selection { case .worktree(let id): return isSelectionValid(id, state: state) case .repository(let id): return state.repositories[id: id] != nil case .archivedWorktrees, .canvas: return true case nil: return false }}
func setSingleWorktreeSelection( _ worktreeID: Worktree.ID?, state: inout RepositoriesFeature.State, recordHistory: Bool = false) { if recordHistory { recordWorktreeHistoryTransition(from: state.selectedWorktreeID, to: worktreeID, state: &state) } state.selection = worktreeID.map(SidebarSelection.worktree) state.selectedWorkspaceChildID = nil if let worktreeID { state.sidebarSelectedWorktreeIDs = [worktreeID] } else { state.sidebarSelectedWorktreeIDs = [] }}
enum WorktreeHistoryDirection { case backward case forward}
private let worktreeHistoryStackLimit = 50
func navigateWorktreeHistory( direction: WorktreeHistoryDirection, state: inout RepositoriesFeature.State) -> Effect<RepositoriesFeature.Action> { guard !state.isShowingShelf, !state.isShowingCanvas else { return .none } guard let currentID = state.selectedWorktreeID else { return .none } var sourceStack = direction == .backward ? state.worktreeHistoryBackStack : state.worktreeHistoryForwardStack guard let destinationID = popValidWorktreeHistoryDestination(from: &sourceStack, currentID: currentID, state: state) else { if direction == .backward { state.worktreeHistoryBackStack = sourceStack } else { state.worktreeHistoryForwardStack = sourceStack } return .none }
if direction == .backward { state.worktreeHistoryBackStack = sourceStack pushWorktreeHistoryID(currentID, onto: &state.worktreeHistoryForwardStack) } else { state.worktreeHistoryForwardStack = sourceStack pushWorktreeHistoryID(currentID, onto: &state.worktreeHistoryBackStack) } setSingleWorktreeSelection(destinationID, state: &state, recordHistory: false) state.openedWorktreeIDs.insert(destinationID) // Match sidebar/arrow navigation: focus the terminal of the worktree we land on. state.pendingTerminalFocusWorktreeIDs.insert(destinationID) return .send(.delegate(.selectedWorktreeChanged(state.worktree(for: destinationID))))}
func recordWorktreeHistoryTransition( from previousID: Worktree.ID?, to nextID: Worktree.ID?, state: inout RepositoriesFeature.State) { // Shelf / Canvas are mode switches, not worktree navigation — leave // history frozen so users can resume Back/Forward where they left off. guard !state.isShowingShelf, !state.isShowingCanvas else { return } // No-op transitions (same worktree, or both endpoints nil) leave history alone. if previousID == nextID { return } // Any user-initiated selection change invalidates the redo path. Crucially // this also fires when the user navigates to/from .repository or // .archivedWorktrees (one or both IDs nil), so a stale forward stack // can't carry over into an unrelated path. state.worktreeHistoryForwardStack = [] // Only push onto the back stack when leaving a still-valid worktree; we // don't want non-worktree selections (repository / archived) showing up // as Back targets. guard let previousID, isSelectionValid(previousID, state: state) else { return } pushWorktreeHistoryID(previousID, onto: &state.worktreeHistoryBackStack)}
private func popValidWorktreeHistoryDestination( from stack: inout [Worktree.ID], currentID: Worktree.ID, state: RepositoriesFeature.State) -> Worktree.ID? { while let candidateID = stack.popLast() { guard candidateID != currentID, isSelectionValid(candidateID, state: state) else { continue } return candidateID } return nil}
private func pushWorktreeHistoryID(_ id: Worktree.ID, onto stack: inout [Worktree.ID]) { stack.append(id) if stack.count > worktreeHistoryStackLimit { stack.removeFirst(stack.count - worktreeHistoryStackLimit) }}
func pruneWorktreeHistoryTails(state: inout RepositoriesFeature.State) { pruneWorktreeHistoryTail(stack: &state.worktreeHistoryBackStack, state: state) pruneWorktreeHistoryTail(stack: &state.worktreeHistoryForwardStack, state: state)}
private func pruneWorktreeHistoryTail( stack: inout [Worktree.ID], state: RepositoriesFeature.State) { while let last = stack.last, last == state.selectedWorktreeID || !isSelectionValid(last, state: state) { stack.removeLast() }}
func repositoryForWorktreeCreation( _ state: RepositoriesFeature.State) -> Repository? { if let selectedRepository = state.selectedRepository, selectedRepository.capabilities.supportsWorktrees { return selectedRepository } if let selectedWorktreeID = state.selectedWorktreeID { if let pending = state.pendingWorktree(for: selectedWorktreeID) { if let repository = state.repositories[id: pending.repositoryID], repository.capabilities.supportsWorktrees { return repository } return nil } for repository in state.repositories where repository.worktrees[id: selectedWorktreeID] != nil { if repository.capabilities.supportsWorktrees { return repository } return nil } } if state.repositories.count == 1, let repository = state.repositories.first, repository.capabilities.supportsWorktrees { return repository } return nil}
func prunePinnedWorktreeIDs(state: inout RepositoriesFeature.State) -> Bool { let availableIDs = Set(state.repositories.flatMap { $0.worktrees.map(\.id) }) let mainIDs = Set( state.repositories.compactMap { repository in repository.worktrees.first(where: { state.isMainWorktree($0) })?.id } ) let archivedSet = state.archivedWorktreeIDSet let pruned = state.pinnedWorktreeIDs.filter { availableIDs.contains($0) && !mainIDs.contains($0) && !archivedSet.contains($0) } if pruned != state.pinnedWorktreeIDs { state.pinnedWorktreeIDs = pruned return true } return false}
func pruneRepositoryOrderIDs( roots: [URL], state: inout RepositoriesFeature.State) -> Bool { let rootIDs = roots.map { $0.standardizedFileURL.path(percentEncoded: false) } let availableIDs = Set(rootIDs + state.repositories.map(\.id)) let pruned = state.repositoryOrderIDs.filter { availableIDs.contains($0) } if pruned != state.repositoryOrderIDs { state.repositoryOrderIDs = pruned return true } return false}
func pruneWorktreeOrderByRepository( roots: [URL], state: inout RepositoriesFeature.State) -> Bool { let rootIDs = Set(roots.map { $0.standardizedFileURL.path(percentEncoded: false) }) let repositoriesByID = Dictionary( state.repositories.map { ($0.id, $0) }, uniquingKeysWith: { first, _ in first } ) let pinnedSet = Set(state.pinnedWorktreeIDs) let archivedSet = state.archivedWorktreeIDSet var pruned: [Repository.ID: [Worktree.ID]] = [:] for (repoID, order) in state.worktreeOrderByRepository { guard let repository = repositoriesByID[repoID] else { if rootIDs.contains(repoID), !order.isEmpty { pruned[repoID] = order } continue } let mainID = repository.worktrees.first(where: { state.isMainWorktree($0) })?.id let availableIDs = Set(repository.worktrees.map(\.id)) var seen: Set<Worktree.ID> = [] var filtered: [Worktree.ID] = [] for id in order { if availableIDs.contains(id), id != mainID, !pinnedSet.contains(id), !archivedSet.contains(id), seen.insert(id).inserted { filtered.append(id) } } if !filtered.isEmpty { pruned[repoID] = filtered } } if pruned != state.worktreeOrderByRepository { state.worktreeOrderByRepository = pruned return true } return false}
func pruneArchivedWorktrees( availableWorktreeIDs: Set<Worktree.ID>, state: inout RepositoriesFeature.State) -> Bool { let pruned = state.archivedWorktrees.filter { availableWorktreeIDs.contains($0.id) } if pruned != state.archivedWorktrees { state.archivedWorktrees = pruned return true } return false}
func firstAvailableWorktreeID( from repositories: [Repository], state: RepositoriesFeature.State) -> Worktree.ID? { for repository in repositories { if let first = state.orderedWorktrees(in: repository).first { return first.id } } return nil}
func firstAvailableWorktreeID( in repositoryID: Repository.ID, state: RepositoriesFeature.State) -> Worktree.ID? { guard let repository = state.repositories[id: repositoryID] else { return nil } return state.orderedWorktrees(in: repository).first?.id}
func findWorktreeAndRepository( worktreeID: Worktree.ID, state: RepositoriesFeature.State) -> (worktree: Worktree, repository: Repository)? { for repository in state.repositories { if let worktree = repository.worktrees[id: worktreeID] { return (worktree, repository) } } return nil}
func nextWorktreeID( afterRemoving worktree: Worktree, in repository: Repository, state: RepositoriesFeature.State) -> Worktree.ID? { let orderedIDs = state.orderedWorktrees(in: repository).map(\.id) guard let index = orderedIDs.firstIndex(of: worktree.id) else { return nil } let nextIndex = index + 1 if nextIndex < orderedIDs.count { return orderedIDs[nextIndex] } if index > 0 { return orderedIDs[index - 1] } return nil}