update repo list

crates/signed_state/src/lib.rs

@@ -12,7 +12,7 @@ use gpui::{App, AppContext, Entity};
 pub use nostr_sdk::prelude::Timestamp;
 pub use profile::{Profile, ProfileStore};
 pub use repo::RepoStore;
-pub use repo_list::RepoListStore;
+pub use repo_list::{RepoActivityCounts, RepoListStore};
 use signed_nostr::new_backend;
 pub use utils::shorten_pubkey;
 

crates/signed_state/src/repo_list.rs

@@ -20,6 +20,28 @@ struct GlobalRepoListStore(Entity<RepoListStore>);
 
 impl Global for GlobalRepoListStore {}
 
+/// Counts of NIP-34 activity events per repository, used to rank the
+/// explore list by popularity. Each patch event is a pushed commit (or a
+/// small commit series), which is the closest cross-repository proxy for
+/// commit count available from event data alone.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct RepoActivityCounts {
+    /// Root `30611` issue events addressed to the repository.
+    pub issues: u32,
+    /// Root `3063` pull request events addressed to the repository
+    /// (updates to a PR are not new PRs and don't count).
+    pub pull_requests: u32,
+    /// `1617` patch events addressed to the repository.
+    pub commits: u32,
+}
+
+impl RepoActivityCounts {
+    /// Total issues + pull requests + commits; the popularity ranking key.
+    pub fn score(self) -> u32 {
+        self.issues + self.pull_requests + self.commits
+    }
+}
+
 /// Store listing repository announcements (global discovery or per-author).
 ///
 /// The all-repos store (`author: None`) is created at startup by
@@ -31,6 +53,9 @@ pub struct RepoListStore {
     /// Latest known activity timestamp per repository
     /// (announcements, state updates, patches, PRs, issues, statuses).
     pub last_activity: Arc<HashMap<RepoAddr, Timestamp>>,
+    /// Issues + pull requests + commits per repository, for the Popular
+    /// ranking of the explore list.
+    pub counts: Arc<HashMap<RepoAddr, RepoActivityCounts>>,
     author: Option<PublicKey>,
     refreshing: bool,
     refresh_dirty: bool,
@@ -88,6 +113,7 @@ impl RepoListStore {
         let mut store = Self {
             announcements: Arc::new(Vec::new()),
             last_activity: Arc::new(HashMap::new()),
+            counts: Arc::new(HashMap::new()),
             author,
             refreshing: false,
             refresh_dirty: false,
@@ -254,11 +280,38 @@ impl RepoListStore {
                 }
             }
 
-            Ok::<_, Error>((announcements, last_activity))
+            // Popularity counts per repository (issues, pull requests and
+            // patches). Unbounded, unlike the windowed activity query
+            // above, so totals are exact.
+            let mut counts: HashMap<RepoAddr, RepoActivityCounts> = HashMap::new();
+            let count_filter =
+                Filter::new().kinds([Kind::GitIssue, Kind::GitPullRequest, Kind::GitPatch]);
+            for event in client.database().query(count_filter).await? {
+                if deletions.is_deleted(&event) {
+                    continue;
+                }
+                for addr in event.tags.coordinates() {
+                    // Skip events for repos we don't list, so the map can't
+                    // grow beyond the number of announcements.
+                    if addr.kind != Kind::GitRepoAnnouncement || !last_activity.contains_key(&addr)
+                    {
+                        continue;
+                    }
+                    let entry = counts.entry(addr).or_default();
+                    match event.kind {
+                        Kind::GitIssue => entry.issues += 1,
+                        Kind::GitPullRequest => entry.pull_requests += 1,
+                        Kind::GitPatch => entry.commits += 1,
+                        _ => {}
+                    }
+                }
+            }
+
+            Ok::<_, Error>((announcements, last_activity, counts))
         });
 
         self.tasks.push(cx.spawn(async move |this, cx| {
-            let (announcements, last_activity) = match work.await {
+            let (announcements, last_activity, counts) = match work.await {
                 Ok(results) => results,
                 // Database errors are transient; keep the last list.
                 Err(_) => {
@@ -271,6 +324,7 @@ impl RepoListStore {
             let again = this.update(cx, |this, cx| {
                 this.announcements = Arc::new(announcements);
                 this.last_activity = Arc::new(last_activity);
+                this.counts = Arc::new(counts);
                 cx.notify();
 
                 this.refreshing = false;