Undisclosed project number 1234
feat(superjam): stars/follows/followers/reactions list commands
Lewis: May this revision serve well! <lu5a@proton.me>
author
Lewis
date
(May 22, 2026, 11:25 PM +0300)
commit
5ea60a19
5ea60a19c96883a9caae3153a9ab65b385fe10cb
parent
b16114ba
b16114ba8d257af3233b9765f5539e0a40aa58c4
change-id
qmpsvrtu
qmpsvrtuomsqnywszuqzuusvqkwupnlq
+827
-8
+69
crates/superjam/src/cli.rs
+69
crates/superjam/src/cli.rs
···
86
86
React(ReactArgs),
87
87
#[command(about = "Remove a reaction")]
88
88
Unreact(ReactArgs),
89
+
#[command(about = "Star listings")]
90
+
Stars(StarsCmd),
91
+
#[command(about = "Follow listings")]
92
+
Follows(FollowsCmd),
93
+
#[command(about = "List followers of a user")]
94
+
Followers(FollowersArgs),
95
+
#[command(about = "Reaction listings")]
96
+
Reactions(ReactionsCmd),
89
97
#[command(about = "Profile view")]
90
98
Profile(ProfileCmd),
91
99
#[command(about = "Config inspection")]
···
272
280
pub at_uri: AtUri<DefaultStr>,
273
281
#[arg(value_name = "EMOJI")]
274
282
pub emoji: Emoji,
283
+
}
284
+
285
+
#[derive(Args, Debug)]
286
+
pub struct StarsCmd {
287
+
#[command(subcommand)]
288
+
pub action: StarsAction,
289
+
}
290
+
291
+
#[derive(Subcommand, Debug)]
292
+
pub enum StarsAction {
293
+
#[command(about = "Stars created by a user")]
294
+
List {
295
+
#[arg(value_name = "USER")]
296
+
user: Option<AtIdentifier<DefaultStr>>,
297
+
},
298
+
#[command(about = "Stars received by a repo")]
299
+
On {
300
+
#[arg(value_name = "REPO")]
301
+
repo: Option<RepoRef>,
302
+
},
303
+
}
304
+
305
+
#[derive(Args, Debug)]
306
+
pub struct FollowsCmd {
307
+
#[command(subcommand)]
308
+
pub action: FollowsAction,
309
+
}
310
+
311
+
#[derive(Subcommand, Debug)]
312
+
pub enum FollowsAction {
313
+
#[command(about = "Users that a user follows")]
314
+
List {
315
+
#[arg(value_name = "USER")]
316
+
user: Option<AtIdentifier<DefaultStr>>,
317
+
},
318
+
}
319
+
320
+
#[derive(Args, Debug)]
321
+
pub struct FollowersArgs {
322
+
#[arg(value_name = "USER")]
323
+
pub user: AtIdentifier<DefaultStr>,
324
+
}
325
+
326
+
#[derive(Args, Debug)]
327
+
pub struct ReactionsCmd {
328
+
#[command(subcommand)]
329
+
pub action: ReactionsAction,
330
+
}
331
+
332
+
#[derive(Subcommand, Debug)]
333
+
pub enum ReactionsAction {
334
+
#[command(about = "Reactions created by a user")]
335
+
List {
336
+
#[arg(value_name = "USER")]
337
+
user: Option<AtIdentifier<DefaultStr>>,
338
+
},
339
+
#[command(about = "Reactions received by an at-uri")]
340
+
On {
341
+
#[arg(value_name = "AT-URI")]
342
+
at_uri: AtUri<DefaultStr>,
343
+
},
275
344
}
276
345
277
346
#[derive(Args, Debug)]
+97
-6
crates/superjam/src/cmd/handles.rs
+97
-6
crates/superjam/src/cmd/handles.rs
···
31
31
AtIdentifier::Handle(_) => None,
32
32
};
33
33
let Some(did) = did else { return };
34
-
if handles.contains_key(&did) {
34
+
resolve_did_handle(appview, &did, handles).await;
35
+
}
36
+
37
+
pub async fn resolve_did_handle(
38
+
appview: &AppviewClient,
39
+
did: &Did,
40
+
handles: &mut HashMap<Did, Handle<DefaultStr>>,
41
+
) {
42
+
if handles.contains_key(did) {
35
43
return;
36
44
}
37
45
let ident = AtIdentifier::Did(did.clone());
···
40
48
handle: Some(handle),
41
49
..
42
50
}) => {
43
-
handles.insert(did, handle);
51
+
handles.insert(did.clone(), handle);
44
52
}
45
53
Ok(_) => {}
46
54
Err(e) => {
···
49
57
}
50
58
}
51
59
60
+
pub fn did_label(did: &Did, handles: &HashMap<Did, Handle<DefaultStr>>) -> String {
61
+
handles
62
+
.get(did)
63
+
.map(|h| h.as_str().to_owned())
64
+
.unwrap_or_else(|| did.as_str().to_owned())
65
+
}
66
+
67
+
pub fn display_uri(uri: &AtUri<DefaultStr>, handles: &HashMap<Did, Handle<DefaultStr>>) -> String {
68
+
let AtIdentifier::Did(d) = uri.authority() else {
69
+
return uri.to_string();
70
+
};
71
+
let Ok(owned) = Did::new_owned(d.as_str()) else {
72
+
return uri.to_string();
73
+
};
74
+
let Some(handle) = handles.get(&owned) else {
75
+
return uri.to_string();
76
+
};
77
+
let raw = uri.to_string();
78
+
let prefix = format!("at://{}", d.as_str());
79
+
match raw.strip_prefix(&prefix) {
80
+
Some(rest) => format!("at://{}{}", handle.as_str(), rest),
81
+
None => raw,
82
+
}
83
+
}
84
+
52
85
pub async fn resolve_handles_for_uris<'a, I>(
53
86
appview: &AppviewClient,
54
87
uris: I,
···
56
89
where
57
90
I: IntoIterator<Item = &'a AtUri<DefaultStr>>,
58
91
{
59
-
let dids: Vec<Did> = uris
92
+
let dids: HashSet<Did> = uris
60
93
.into_iter()
61
94
.filter_map(|u| match u.authority() {
62
95
AtIdentifier::Did(d) => Did::new_owned(d.as_str()).ok(),
63
96
AtIdentifier::Handle(_) => None,
64
97
})
65
-
.collect::<HashSet<_>>()
66
-
.into_iter()
67
98
.collect();
68
-
let lookups = dids.into_iter().map(|did| async move {
99
+
resolve_handles_for_dids(appview, dids.iter()).await
100
+
}
101
+
102
+
pub async fn resolve_handles_for_dids<'a, I>(
103
+
appview: &AppviewClient,
104
+
dids: I,
105
+
) -> HashMap<Did, Handle<DefaultStr>>
106
+
where
107
+
I: IntoIterator<Item = &'a Did>,
108
+
{
109
+
let unique: HashSet<Did> = dids.into_iter().cloned().collect();
110
+
let lookups = unique.into_iter().map(|did| async move {
69
111
let ident = AtIdentifier::Did(did.clone());
70
112
let handle = match appview.resolve_mini_doc(&ident).await {
71
113
Ok(MiniDoc { handle, .. }) => handle,
···
113
155
Handle::new_owned("nel.pet").unwrap(),
114
156
);
115
157
assert_eq!(author_label(&uri, &handles), "nel.pet");
158
+
}
159
+
160
+
#[test]
161
+
fn display_uri_rewrites_did_authority_to_handle() {
162
+
let uri = AtUri::<DefaultStr>::from_parts_owned(
163
+
"did:plc:nel",
164
+
"sh.tangled.repo.issue",
165
+
"3lqj1aaaaaaaa",
166
+
)
167
+
.unwrap();
168
+
let mut handles: HashMap<Did, Handle<DefaultStr>> = HashMap::new();
169
+
handles.insert(
170
+
Did::new_owned("did:plc:nel").unwrap(),
171
+
Handle::new_owned("nel.pet").unwrap(),
172
+
);
173
+
assert_eq!(
174
+
display_uri(&uri, &handles),
175
+
"at://nel.pet/sh.tangled.repo.issue/3lqj1aaaaaaaa",
176
+
);
177
+
}
178
+
179
+
#[test]
180
+
fn display_uri_falls_back_to_did_when_handle_missing() {
181
+
let uri = AtUri::<DefaultStr>::from_parts_owned(
182
+
"did:plc:nel",
183
+
"sh.tangled.repo.issue",
184
+
"3lqj1aaaaaaaa",
185
+
)
186
+
.unwrap();
187
+
let handles: HashMap<Did, Handle<DefaultStr>> = HashMap::new();
188
+
assert_eq!(
189
+
display_uri(&uri, &handles),
190
+
"at://did:plc:nel/sh.tangled.repo.issue/3lqj1aaaaaaaa",
191
+
);
192
+
}
193
+
194
+
#[test]
195
+
fn display_uri_preserves_handle_authority() {
196
+
let uri = AtUri::<DefaultStr>::from_parts_owned(
197
+
"nel.pet",
198
+
"sh.tangled.repo.issue",
199
+
"3lqj1aaaaaaaa",
200
+
)
201
+
.unwrap();
202
+
let handles: HashMap<Did, Handle<DefaultStr>> = HashMap::new();
203
+
assert_eq!(
204
+
display_uri(&uri, &handles),
205
+
"at://nel.pet/sh.tangled.repo.issue/3lqj1aaaaaaaa",
206
+
);
116
207
}
117
208
}
+1
crates/superjam/src/cmd/mod.rs
+1
crates/superjam/src/cmd/mod.rs
+43
-2
crates/superjam/src/main.rs
+43
-2
crates/superjam/src/main.rs
···
15
15
mod format;
16
16
17
17
use cli::{
18
-
AuthCmd, Cli, Command, ConfigCmd, FollowArgs, IssueCmd, PrCmd, ProfileCmd, ReactArgs, RepoCmd,
19
-
StarArgs,
18
+
AuthCmd, Cli, Command, ConfigCmd, FollowArgs, FollowersArgs, FollowsAction, FollowsCmd,
19
+
IssueCmd, PrCmd, ProfileCmd, ReactArgs, ReactionsAction, ReactionsCmd, RepoCmd, StarArgs,
20
+
StarsAction, StarsCmd,
20
21
};
21
22
use cmd::auth::AuthError;
22
23
use cmd::issue::IssueError;
···
25
26
use cmd::repo::RepoError;
26
27
use cmd::repo_locator::LocateError;
27
28
use cmd::social::{SocialAction, SocialError};
29
+
use cmd::social_list::{SocialListAction, SocialListError};
28
30
use context::{ContextError, IdentityResolveError};
29
31
use format::ColorMode;
30
32
···
92
94
#[error(transparent)]
93
95
Social(#[from] SocialError),
94
96
#[error(transparent)]
97
+
SocialList(#[from] SocialListError),
98
+
#[error(transparent)]
95
99
Profile(#[from] ProfileError),
96
100
#[error("`{0}` is not yet implemented")]
97
101
Pending(&'static str),
···
108
112
Self::Issue(e) => cmd::issue::exit_kind(e),
109
113
Self::Pr(e) => cmd::pr::exit_kind(e),
110
114
Self::Social(e) => cmd::social::exit_kind(e),
115
+
Self::SocialList(e) => cmd::social_list::exit_kind(e),
111
116
Self::Profile(e) => cmd::profile::exit_kind(e),
112
117
Self::Pending(_) => ExitKind::UserError,
113
118
Self::Output(_) => ExitKind::Internal,
···
122
127
Self::Issue(_) => "issue",
123
128
Self::Pr(_) => "pr",
124
129
Self::Social(_) => "social",
130
+
Self::SocialList(_) => "social",
125
131
Self::Profile(_) => "profile",
126
132
Self::Pending(_) => "not-implemented",
127
133
Self::Output(_) => "output",
···
294
300
let repo = context::resolve_repo_or_cwd(&global, repo)?;
295
301
run_social(SocialAction::Unstar(repo), &global, mode, out).await
296
302
}
303
+
Command::Stars(StarsCmd { action }) => {
304
+
let action = match action {
305
+
StarsAction::List { user } => SocialListAction::StarsList(user),
306
+
StarsAction::On { repo } => {
307
+
let repo = context::resolve_repo_or_cwd(&global, repo)?;
308
+
SocialListAction::StarsOn(repo)
309
+
}
310
+
};
311
+
run_social_list(action, &global, mode, out).await
312
+
}
313
+
Command::Follows(FollowsCmd { action }) => {
314
+
let FollowsAction::List { user } = action;
315
+
run_social_list(SocialListAction::FollowsList(user), &global, mode, out).await
316
+
}
317
+
Command::Followers(FollowersArgs { user }) => {
318
+
run_social_list(SocialListAction::Followers(user), &global, mode, out).await
319
+
}
320
+
Command::Reactions(ReactionsCmd { action }) => {
321
+
let action = match action {
322
+
ReactionsAction::List { user } => SocialListAction::ReactionsList(user),
323
+
ReactionsAction::On { at_uri } => SocialListAction::ReactionsOn(at_uri),
324
+
};
325
+
run_social_list(action, &global, mode, out).await
326
+
}
297
327
Command::Repo(RepoCmd { action }) => {
298
328
let ctx = cmd::repo::RepoCtx::load(&global)?;
299
329
cmd::repo::run(action, &ctx, &global, mode, out).await?;
···
320
350
) -> Result<(), CliError> {
321
351
let ctx = cmd::session::SessionCtx::load(global).map_err(SocialError::Session)?;
322
352
cmd::social::run(action, &ctx, mode, out).await?;
353
+
Ok(())
354
+
}
355
+
356
+
async fn run_social_list(
357
+
action: SocialListAction,
358
+
global: &cli::GlobalOpts,
359
+
mode: Mode,
360
+
out: &mut dyn Write,
361
+
) -> Result<(), CliError> {
362
+
let ctx = cmd::session::SessionCtx::load(global).map_err(SocialListError::Session)?;
363
+
cmd::social_list::run(action, &ctx, mode, out).await?;
323
364
Ok(())
324
365
}
325
366