tenant.openagents/omega

1use crate::git_status_icon;
2use git::status::{FileStatus, StatusCode, TrackedStatus, UnmergedStatus, UnmergedStatusCode};
3use gpui::{App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity};
4use picker::{Picker, PickerDelegate, PickerEditorPosition};
5use project::{Project, git_store::Repository};
6use std::sync::Arc;
7use ui::{ListItem, ListItemSpacing, prelude::*};
8use workspace::{ModalView, Workspace};
9
10pub fn register(workspace: &mut Workspace) {
11    workspace.register_action(open);
12}
13
14pub fn open(
15    workspace: &mut Workspace,
16    _: &zed_actions::git::SelectRepo,
17    window: &mut Window,
18    cx: &mut Context<Workspace>,
19) {
20    let project = workspace.project().clone();
21    workspace.toggle_modal(window, cx, |window, cx| {
22        RepositorySelector::new(project, rems(34.), window, cx)
23    })
24}
25
26pub struct RepositorySelector {
27    picker: Entity<Picker<RepositorySelectorDelegate>>,
28}
29
30impl RepositorySelector {
31    pub fn new(
32        project_handle: Entity<Project>,
33        width: Rems,
34        window: &mut Window,
35        cx: &mut Context<Self>,
36    ) -> Self {
37        let git_store = project_handle.read(cx).git_store().clone();
38        let repository_entries = git_store.update(cx, |git_store, _cx| {
39            let mut repos: Vec<_> = git_store.repositories().values().cloned().collect();
40
41            repos.sort_by(|a, b| {
42                a.read(_cx)
43                    .display_name()
44                    .to_lowercase()
45                    .cmp(&b.read(_cx).display_name().to_lowercase())
46            });
47
48            repos
49        });
50        let filtered_repositories = repository_entries.clone();
51
52        let active_repository = git_store.read(cx).active_repository();
53        let selected_index = active_repository
54            .as_ref()
55            .and_then(|active| filtered_repositories.iter().position(|repo| repo == active))
56            .unwrap_or(0);
57        let delegate = RepositorySelectorDelegate {
58            repository_selector: cx.entity().downgrade(),
59            repository_entries,
60            filtered_repositories,
61            active_repository,
62            selected_index,
63        };
64
65        let picker = cx.new(|cx| {
66            Picker::uniform_list(delegate, window, cx)
67                .initial_width(width)
68                .show_scrollbar(true)
69        });
70
71        RepositorySelector { picker }
72    }
73}
74
75//pub(crate) fn filtered_repository_entries(
76//    git_store: &GitStore,
77//    cx: &App,
78//) -> Vec<Entity<Repository>> {
79//    let repositories = git_store
80//        .repositories()
81//        .values()
82//        .sorted_by_key(|repo| {
83//            let repo = repo.read(cx);
84//            (
85//                repo.dot_git_abs_path.clone(),
86//                repo.worktree_abs_path.clone(),
87//            )
88//        })
89//        .collect::<Vec<&Entity<Repository>>>();
90//
91//    repositories
92//        .chunk_by(|a, b| a.read(cx).dot_git_abs_path == b.read(cx).dot_git_abs_path)
93//        .flat_map(|chunk| {
94//            let has_non_single_file_worktree = chunk
95//                .iter()
96//                .any(|repo| !repo.read(cx).is_from_single_file_worktree);
97//            chunk.iter().filter(move |repo| {
98//                // Remove any entry that comes from a single file worktree and represents a repository that is also represented by a non-single-file worktree.
99//                !repo.read(cx).is_from_single_file_worktree || !has_non_single_file_worktree
100//            })
101//        })
102//        .map(|&repo| repo.clone())
103//        .collect()
104//}
105
106impl EventEmitter<DismissEvent> for RepositorySelector {}
107
108impl Focusable for RepositorySelector {
109    fn focus_handle(&self, cx: &App) -> FocusHandle {
110        self.picker.focus_handle(cx)
111    }
112}
113
114impl Render for RepositorySelector {
115    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
116        div()
117            .key_context("GitRepositorySelector")
118            .child(self.picker.clone())
119    }
120}
121
122impl ModalView for RepositorySelector {}
123
124pub struct RepositorySelectorDelegate {
125    repository_selector: WeakEntity<RepositorySelector>,
126    repository_entries: Vec<Entity<Repository>>,
127    filtered_repositories: Vec<Entity<Repository>>,
128    active_repository: Option<Entity<Repository>>,
129    selected_index: usize,
130}
131
132impl RepositorySelectorDelegate {
133    pub fn update_repository_entries(&mut self, all_repositories: Vec<Entity<Repository>>) {
134        self.repository_entries = all_repositories.clone();
135        self.filtered_repositories = all_repositories;
136        self.selected_index = self
137            .active_repository
138            .as_ref()
139            .and_then(|active| {
140                self.filtered_repositories
141                    .iter()
142                    .position(|repo| repo == active)
143            })
144            .unwrap_or(0);
145    }
146}
147
148impl PickerDelegate for RepositorySelectorDelegate {
149    type ListItem = ListItem;
150
151    fn name() -> &'static str {
152        "repository selector"
153    }
154
155    fn match_count(&self) -> usize {
156        self.filtered_repositories.len()
157    }
158
159    fn selected_index(&self) -> usize {
160        self.selected_index
161    }
162
163    fn set_selected_index(
164        &mut self,
165        ix: usize,
166        _window: &mut Window,
167        cx: &mut Context<Picker<Self>>,
168    ) {
169        self.selected_index = ix.min(self.filtered_repositories.len().saturating_sub(1));
170        cx.notify();
171    }
172
173    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
174        "Select a repository...".into()
175    }
176
177    fn editor_position(&self) -> PickerEditorPosition {
178        PickerEditorPosition::End
179    }
180
181    fn update_matches(
182        &mut self,
183        query: String,
184        window: &mut Window,
185        cx: &mut Context<Picker<Self>>,
186    ) -> Task<()> {
187        let all_repositories = self.repository_entries.clone();
188
189        let repo_names: Vec<(Entity<Repository>, String)> = all_repositories
190            .iter()
191            .map(|repo| (repo.clone(), repo.read(cx).display_name().to_lowercase()))
192            .collect();
193
194        cx.spawn_in(window, async move |this, cx| {
195            let filtered_repositories = cx
196                .background_spawn(async move {
197                    if query.is_empty() {
198                        all_repositories
199                    } else {
200                        let query_lower = query.to_lowercase();
201                        repo_names
202                            .into_iter()
203                            .filter(|(_, display_name)| display_name.contains(&query_lower))
204                            .map(|(repo, _)| repo)
205                            .collect()
206                    }
207                })
208                .await;
209
210            this.update_in(cx, |this, window, cx| {
211                let mut sorted_repositories = filtered_repositories;
212                sorted_repositories.sort_by(|a, b| {
213                    a.read(cx)
214                        .display_name()
215                        .to_lowercase()
216                        .cmp(&b.read(cx).display_name().to_lowercase())
217                });
218                let selected_index = this
219                    .delegate
220                    .active_repository
221                    .as_ref()
222                    .and_then(|active| sorted_repositories.iter().position(|repo| repo == active))
223                    .unwrap_or(0);
224                this.delegate.filtered_repositories = sorted_repositories;
225                this.delegate.set_selected_index(selected_index, window, cx);
226                cx.notify();
227            })
228            .ok();
229        })
230    }
231
232    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
233        let Some(selected_repo) = self.filtered_repositories.get(self.selected_index) else {
234            return;
235        };
236        selected_repo.update(cx, |selected_repo, cx| {
237            selected_repo.set_as_active_repository(cx)
238        });
239        self.dismissed(window, cx);
240    }
241
242    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
243        self.repository_selector
244            .update(cx, |_this, cx| cx.emit(DismissEvent))
245            .ok();
246    }
247
248    fn render_match(
249        &self,
250        ix: usize,
251        selected: bool,
252        _window: &mut Window,
253        cx: &mut Context<Picker<Self>>,
254    ) -> Option<Self::ListItem> {
255        let repo_info = self.filtered_repositories.get(ix)?;
256        let repo = repo_info.read(cx);
257        let display_name = repo.display_name();
258        let summary = repo.status_summary();
259        let is_active = self
260            .active_repository
261            .as_ref()
262            .is_some_and(|active| active == repo_info);
263
264        let mut item = ListItem::new(ix)
265            .inset(true)
266            .spacing(ListItemSpacing::Sparse)
267            .toggle_state(selected)
268            .child(
269                h_flex()
270                    .gap_1()
271                    .child(Label::new(display_name))
272                    .when(is_active, |this| {
273                        this.child(
274                            Icon::new(IconName::Check)
275                                .size(IconSize::Small)
276                                .color(Color::Accent),
277                        )
278                    }),
279            );
280
281        if summary.count > 0 {
282            let status = if summary.conflict > 0 {
283                FileStatus::Unmerged(UnmergedStatus {
284                    first_head: UnmergedStatusCode::Updated,
285                    second_head: UnmergedStatusCode::Updated,
286                })
287            } else if summary.worktree.deleted > 0 || summary.index.deleted > 0 {
288                FileStatus::Tracked(TrackedStatus {
289                    index_status: StatusCode::Deleted,
290                    worktree_status: StatusCode::Unmodified,
291                })
292            } else if summary.worktree.modified > 0 || summary.index.modified > 0 {
293                FileStatus::Tracked(TrackedStatus {
294                    index_status: StatusCode::Modified,
295                    worktree_status: StatusCode::Unmodified,
296                })
297            } else {
298                FileStatus::Tracked(TrackedStatus {
299                    index_status: StatusCode::Added,
300                    worktree_status: StatusCode::Unmodified,
301                })
302            };
303            item = item.end_slot(div().pr_2().child(git_status_icon(status)));
304        }
305
306        Some(item)
307    }
308}
309