328 lines
11 KiB
Rust
328 lines
11 KiB
Rust
use std::collections::HashMap;
|
|
use std::fmt::Write as _;
|
|
|
|
use matrix_sdk::{
|
|
Room,
|
|
ruma::{OwnedEventId, OwnedUserId, events::room::message::MessageType},
|
|
};
|
|
|
|
use crate::types::TimelineItem;
|
|
|
|
/// Format a unix-seconds timestamp as `YYYY-MM-DD HH:MM` UTC. Returns "?" for 0.
|
|
pub fn format_ts(secs: i64) -> String {
|
|
if secs == 0 {
|
|
return "?".into();
|
|
}
|
|
let days = secs.div_euclid(86400);
|
|
let day_secs = secs.rem_euclid(86400);
|
|
let (y, m, d) = days_to_ymd(days);
|
|
let h = day_secs / 3600;
|
|
let min = (day_secs % 3600) / 60;
|
|
format!("{y:04}-{m:02}-{d:02} {h:02}:{min:02}")
|
|
}
|
|
|
|
pub fn chrono_now() -> String {
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
let secs = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.map(|d| d.as_secs() as i64)
|
|
.unwrap_or(0);
|
|
let days = secs / 86400;
|
|
let (y, m, d) = days_to_ymd(days);
|
|
format!("{y:04}-{m:02}-{d:02}")
|
|
}
|
|
|
|
/// Convert days-since-1970-01-01 to (year, month, day). Civil-date algorithm.
|
|
fn days_to_ymd(z: i64) -> (i64, u32, u32) {
|
|
let z = z + 719_468;
|
|
let era = z.div_euclid(146_097);
|
|
let doe = z.rem_euclid(146_097) as u32;
|
|
let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365;
|
|
let y = yoe as i64 + era * 400;
|
|
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
|
let mp = (5 * doy + 2) / 153;
|
|
let d = doy - (153 * mp + 2) / 5 + 1;
|
|
let m = if mp < 10 { mp + 3 } else { mp - 9 };
|
|
(if m <= 2 { y + 1 } else { y }, m, d)
|
|
}
|
|
|
|
pub fn ts_secs_from(ts: matrix_sdk::ruma::UInt) -> i64 {
|
|
let ms: u64 = ts.into();
|
|
i64::try_from(ms).unwrap_or(0) / 1000
|
|
}
|
|
|
|
/// Shorten an event id for prompt display: `$abc123def456...` -> `$abc123de`.
|
|
pub fn short_event_id(id: &OwnedEventId) -> String {
|
|
let s = id.as_str();
|
|
let prefix: String = s.chars().take(9).collect();
|
|
if s.len() > 9 {
|
|
format!("{prefix}…")
|
|
} else {
|
|
prefix
|
|
}
|
|
}
|
|
|
|
/// Resolve a (possibly shortened/ellipsized) event id to a full one by
|
|
/// looking up against the timeline. Returns the matching message's full
|
|
/// event id if found.
|
|
pub fn resolve_event_id(timeline: &[TimelineItem], arg: &str) -> Option<OwnedEventId> {
|
|
let cleaned = arg.trim_end_matches('…').trim_end_matches('.').trim();
|
|
if cleaned.is_empty() {
|
|
return None;
|
|
}
|
|
for item in timeline {
|
|
if let TimelineItem::Message { event_id, .. } = item {
|
|
if event_id.as_str() == cleaned || event_id.as_str().starts_with(cleaned) {
|
|
return Some(event_id.clone());
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Render one timeline item into the prompt.
|
|
/// Messages: `[ts] $eid... [(you) ]@user: body [read by: ...]`
|
|
/// Reactions: `[ts] [(you) ]@user reacted to $eid... with KEY`
|
|
pub fn render_timeline_item(
|
|
prompt: &mut String,
|
|
item: &TimelineItem,
|
|
read_markers: &HashMap<OwnedEventId, Vec<OwnedUserId>>,
|
|
) {
|
|
match item {
|
|
TimelineItem::Message {
|
|
event_id,
|
|
sender,
|
|
body,
|
|
is_self,
|
|
ts,
|
|
..
|
|
} => {
|
|
let ts_str = format_ts(*ts);
|
|
let id = short_event_id(event_id);
|
|
let prefix = if *is_self { "(you) " } else { "" };
|
|
let readers_str = match read_markers.get(event_id) {
|
|
Some(rs) if !rs.is_empty() => {
|
|
let mut sorted = rs.clone();
|
|
sorted.sort();
|
|
let names: Vec<String> = sorted.iter().map(|u| u.to_string()).collect();
|
|
format!(" [read by: {}]", names.join(", "))
|
|
}
|
|
_ => String::new(),
|
|
};
|
|
writeln!(
|
|
prompt,
|
|
"[{ts_str}] {id} {prefix}{sender}: {body}{readers_str}"
|
|
)
|
|
.unwrap();
|
|
}
|
|
TimelineItem::Reaction {
|
|
sender,
|
|
target_event_id,
|
|
key,
|
|
is_self,
|
|
ts,
|
|
} => {
|
|
let ts_str = format_ts(*ts);
|
|
let id = short_event_id(target_event_id);
|
|
let prefix = if *is_self { "(you) " } else { "" };
|
|
writeln!(
|
|
prompt,
|
|
"[{ts_str}] {prefix}{sender} reacted to {id} with {key}"
|
|
)
|
|
.unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Load the last N timeline items (messages + reactions) from the room's
|
|
/// persistent event cache. Returns oldest-first.
|
|
///
|
|
/// We walk events newest-first, collect messages until we have `limit`, then
|
|
/// also include any reactions whose timestamps fall within the message window.
|
|
pub async fn load_timeline(
|
|
room: &Room,
|
|
limit: usize,
|
|
own_user: &OwnedUserId,
|
|
) -> anyhow::Result<Vec<TimelineItem>> {
|
|
use matrix_sdk::ruma::events::AnySyncTimelineEvent;
|
|
|
|
let (cache, _handles) = room.event_cache().await?;
|
|
let events = cache.events().await;
|
|
|
|
let mut messages: Vec<TimelineItem> = Vec::new();
|
|
let mut reactions: Vec<TimelineItem> = Vec::new();
|
|
let mut earliest_message_ts: Option<i64> = None;
|
|
|
|
for ev in events.iter().rev() {
|
|
let raw = ev.raw();
|
|
let Ok(deserialized) = raw.deserialize() else {
|
|
continue;
|
|
};
|
|
let AnySyncTimelineEvent::MessageLike(msg) = deserialized else {
|
|
continue;
|
|
};
|
|
|
|
match msg {
|
|
matrix_sdk::ruma::events::AnySyncMessageLikeEvent::RoomMessage(
|
|
matrix_sdk::ruma::events::SyncMessageLikeEvent::Original(orig),
|
|
) => {
|
|
if messages.len() >= limit {
|
|
continue;
|
|
}
|
|
let MessageType::Text(text) = &orig.content.msgtype else {
|
|
continue;
|
|
};
|
|
let ts = ts_secs_from(orig.origin_server_ts.0);
|
|
let in_reply_to = match &orig.content.relates_to {
|
|
Some(matrix_sdk::ruma::events::room::message::Relation::Reply {
|
|
in_reply_to,
|
|
}) => Some(in_reply_to.event_id.clone()),
|
|
_ => None,
|
|
};
|
|
if earliest_message_ts.is_none_or(|e| ts < e) {
|
|
earliest_message_ts = Some(ts);
|
|
}
|
|
messages.push(TimelineItem::Message {
|
|
event_id: orig.event_id.clone(),
|
|
sender: orig.sender.clone(),
|
|
body: text.body.clone(),
|
|
is_self: &orig.sender == own_user,
|
|
ts,
|
|
in_reply_to,
|
|
});
|
|
}
|
|
matrix_sdk::ruma::events::AnySyncMessageLikeEvent::Reaction(
|
|
matrix_sdk::ruma::events::SyncMessageLikeEvent::Original(orig),
|
|
) => {
|
|
let ts = ts_secs_from(orig.origin_server_ts.0);
|
|
reactions.push(TimelineItem::Reaction {
|
|
sender: orig.sender.clone(),
|
|
target_event_id: orig.content.relates_to.event_id.clone(),
|
|
key: orig.content.relates_to.key.clone(),
|
|
is_self: &orig.sender == own_user,
|
|
ts,
|
|
});
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
if let Some(min_ts) = earliest_message_ts {
|
|
reactions.retain(|r| r.ts() >= min_ts);
|
|
}
|
|
|
|
let mut combined: Vec<TimelineItem> = Vec::with_capacity(messages.len() + reactions.len());
|
|
combined.extend(messages);
|
|
combined.extend(reactions);
|
|
combined.sort_by_key(TimelineItem::ts);
|
|
Ok(combined)
|
|
}
|
|
|
|
/// Fetch a single text message by event_id from the room's event cache.
|
|
pub async fn fetch_message(
|
|
cache: &matrix_sdk::event_cache::RoomEventCache,
|
|
event_id: &matrix_sdk::ruma::EventId,
|
|
own_user: &OwnedUserId,
|
|
) -> Option<TimelineItem> {
|
|
use matrix_sdk::ruma::events::AnySyncTimelineEvent;
|
|
|
|
let ev = cache.find_event(event_id).await?;
|
|
let deserialized = ev.raw().deserialize().ok()?;
|
|
let AnySyncTimelineEvent::MessageLike(msg) = deserialized else {
|
|
return None;
|
|
};
|
|
let matrix_sdk::ruma::events::AnySyncMessageLikeEvent::RoomMessage(
|
|
matrix_sdk::ruma::events::SyncMessageLikeEvent::Original(orig),
|
|
) = msg
|
|
else {
|
|
return None;
|
|
};
|
|
let MessageType::Text(text) = &orig.content.msgtype else {
|
|
return None;
|
|
};
|
|
let ts = ts_secs_from(orig.origin_server_ts.0);
|
|
Some(TimelineItem::Message {
|
|
event_id: orig.event_id.clone(),
|
|
sender: orig.sender.clone(),
|
|
body: text.body.clone(),
|
|
is_self: &orig.sender == own_user,
|
|
ts,
|
|
in_reply_to: None,
|
|
})
|
|
}
|
|
|
|
/// For each message in the timeline, compute the list of OTHER users who
|
|
/// have a read receipt at or after that message. Self is excluded.
|
|
pub async fn compute_read_markers(
|
|
room: &Room,
|
|
timeline: &[TimelineItem],
|
|
own_user: &OwnedUserId,
|
|
) -> HashMap<OwnedEventId, Vec<OwnedUserId>> {
|
|
use matrix_sdk::ruma::events::receipt::{ReceiptThread, ReceiptType};
|
|
|
|
let mut users: Vec<OwnedUserId> = timeline
|
|
.iter()
|
|
.filter(|t| !t.is_self())
|
|
.map(|t| t.sender().clone())
|
|
.collect();
|
|
users.sort();
|
|
users.dedup();
|
|
|
|
let positions: HashMap<OwnedEventId, usize> = timeline
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(i, t)| match t {
|
|
TimelineItem::Message { event_id, .. } => Some((event_id.clone(), i)),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
|
|
let mut readers: HashMap<OwnedEventId, Vec<OwnedUserId>> = HashMap::new();
|
|
|
|
for user in &users {
|
|
if user == own_user {
|
|
continue;
|
|
}
|
|
let (receipt_eid, receipt_ts) = match room
|
|
.load_user_receipt(ReceiptType::Read, ReceiptThread::Unthreaded, user)
|
|
.await
|
|
{
|
|
Ok(Some((eid, r))) => {
|
|
let ts = r.ts.map(|t| ts_secs_from(t.0)).unwrap_or(0);
|
|
(eid, ts)
|
|
}
|
|
_ => continue,
|
|
};
|
|
|
|
let user_msg_idx_inclusive: Option<usize> = if let Some(&p) = positions.get(&receipt_eid) {
|
|
Some(p)
|
|
} else {
|
|
let newest_msg_ts = timeline
|
|
.iter()
|
|
.rev()
|
|
.find_map(|t| match t {
|
|
TimelineItem::Message { ts, .. } => Some(*ts),
|
|
_ => None,
|
|
})
|
|
.unwrap_or(0);
|
|
if receipt_ts > 0 && receipt_ts >= newest_msg_ts {
|
|
Some(timeline.len().saturating_sub(1))
|
|
} else {
|
|
None
|
|
}
|
|
};
|
|
|
|
if let Some(up_to) = user_msg_idx_inclusive {
|
|
for item in timeline.iter().take(up_to + 1) {
|
|
if let TimelineItem::Message { event_id, .. } = item {
|
|
readers
|
|
.entry(event_id.clone())
|
|
.or_default()
|
|
.push(user.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
readers
|
|
}
|