+3

crates/jacquard/src/client.rs

··· 160 160 pub handle: Handle<'static>, 161 161 } 162 162 163 163 + #[cfg(feature = "api")] 163 164 impl From<CreateSessionOutput<'_>> for AtpSession { 164 165 fn from(output: CreateSessionOutput<'_>) -> Self { 165 166 Self { ··· 171 172 } 172 173 } 173 174 175 175 + #[cfg(feature = "api")] 174 176 impl From<RefreshSessionOutput<'_>> for AtpSession { 175 177 fn from(output: RefreshSessionOutput<'_>) -> Self { 176 178 Self { ··· 891 893 } 892 894 } 893 895 896 896 + #[cfg(feature = "api")] 894 897 impl<T: AgentSession + IdentityResolver> AgentSessionExt for T {} 895 898 896 899 impl<A: AgentSession> HttpClient for Agent<A> {

+1

crates/jacquard/src/lib.rs

··· 242 242 /// Prelude with the extension traits you're likely to want and some other stuff 243 243 pub mod prelude { 244 244 pub use crate::client::AgentSession; 245 245 + #[cfg(feature = "api")] 245 246 pub use crate::client::AgentSessionExt; 246 247 pub use crate::client::BasicClient; 247 248 pub use crate::common::http_client::HttpClient;

+332 -13

crates/jacquard/src/richtext.rs

··· 3 3 //! Provides parsing and building of rich text with facets (mentions, links, tags) 4 4 //! and detection of embed candidates (record and external embeds). 5 5 6 6 + #[cfg(feature = "api_bluesky")] 7 7 + use crate::api::app_bsky::richtext::facet::Facet; 6 8 use crate::common::CowStr; 7 9 use jacquard_common::IntoStatic; 8 10 use jacquard_common::types::did::{DID_REGEX, Did}; ··· 32 34 LazyLock::new(|| Regex::new(r"\[([^\]]+)\]\(([^)]+)\)").unwrap()); 33 35 34 36 static TRAILING_PUNCT_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\p{P}+$").unwrap()); 37 37 + 38 38 + /// Default domains that support at-URI extraction from URLs 39 39 + /// (bsky.app URL patterns like /profile/{actor}/post/{rkey}) 40 40 + #[cfg(feature = "api_bluesky")] 41 41 + static DEFAULT_EMBED_DOMAINS: &[&str] = &["bsky.app", "deer.social"]; 35 42 36 43 /// Marker type indicating all facets are resolved (no handles pending DID resolution) 37 44 pub struct Resolved; ··· 119 126 } 120 127 121 128 /// Entry point for parsing text with automatic facet detection 129 129 + /// 130 130 + /// Uses default embed domains (bsky.app, deer.social) for at-URI extraction. 131 131 + /// For custom domains, use [`parse_with_domains`]. 122 132 pub fn parse(text: impl Into<String>) -> RichTextBuilder<Unresolved> { 133 133 + #[cfg(feature = "api_bluesky")] 134 134 + { 135 135 + parse_with_domains(text, DEFAULT_EMBED_DOMAINS) 136 136 + } 137 137 + #[cfg(not(feature = "api_bluesky"))] 138 138 + { 139 139 + parse_with_domains(text, &[]) 140 140 + } 141 141 + } 142 142 + 143 143 + /// Parse text with custom embed domains for at-URI extraction 144 144 + /// 145 145 + /// This allows specifying additional domains (beyond bsky.app and deer.social) 146 146 + /// that use the same URL patterns for records (e.g., /profile/{actor}/post/{rkey}). 147 147 + #[cfg(feature = "api_bluesky")] 148 148 + pub fn parse_with_domains( 149 149 + text: impl Into<String>, 150 150 + embed_domains: &[&str], 151 151 + ) -> RichTextBuilder<Unresolved> { 123 152 let text = text.into(); 124 153 let mut facet_candidates = Vec::new(); 154 154 + let mut embed_candidates = Vec::new(); 125 155 126 156 // Step 1: Detect and strip markdown links first 127 157 let (text_processed, markdown_facets) = detect_markdown_links(&text); 158 158 + 159 159 + // Check markdown links for embed candidates 160 160 + for facet in &markdown_facets { 161 161 + if let FacetCandidate::MarkdownLink { url, .. } = facet { 162 162 + if let Some(embed) = classify_embed(url, embed_domains) { 163 163 + embed_candidates.push(embed); 164 164 + } 165 165 + } 166 166 + } 167 167 + 128 168 facet_candidates.extend(markdown_facets); 129 169 130 170 // Step 2: Detect mentions ··· 133 173 134 174 // Step 3: Detect URLs 135 175 let url_facets = detect_urls(&text_processed); 176 176 + 177 177 + // Check URLs for embed candidates 178 178 + for facet in &url_facets { 179 179 + if let FacetCandidate::Link { range } = facet { 180 180 + let url = &text_processed[range.clone()]; 181 181 + if let Some(embed) = classify_embed(url, embed_domains) { 182 182 + embed_candidates.push(embed); 183 183 + } 184 184 + } 185 185 + } 186 186 + 136 187 facet_candidates.extend(url_facets); 137 188 138 189 // Step 4: Detect tags ··· 142 193 RichTextBuilder { 143 194 text: text_processed, 144 195 facet_candidates, 145 145 - #[cfg(feature = "api_bluesky")] 146 146 - embed_candidates: Vec::new(), 196 196 + embed_candidates, 197 197 + _state: PhantomData, 198 198 + } 199 199 + } 200 200 + 201 201 + /// Parse text without embed detection (no api_bluesky feature) 202 202 + #[cfg(not(feature = "api_bluesky"))] 203 203 + pub fn parse_with_domains( 204 204 + text: impl Into<String>, 205 205 + _embed_domains: &[&str], 206 206 + ) -> RichTextBuilder<Unresolved> { 207 207 + let text = text.into(); 208 208 + let mut facet_candidates = Vec::new(); 209 209 + 210 210 + // Step 1: Detect and strip markdown links first 211 211 + let (text_processed, markdown_facets) = detect_markdown_links(&text); 212 212 + facet_candidates.extend(markdown_facets); 213 213 + 214 214 + // Step 2: Detect mentions 215 215 + let mention_facets = detect_mentions(&text_processed); 216 216 + facet_candidates.extend(mention_facets); 217 217 + 218 218 + // Step 3: Detect URLs 219 219 + let url_facets = detect_urls(&text_processed); 220 220 + facet_candidates.extend(url_facets); 221 221 + 222 222 + // Step 4: Detect tags 223 223 + let tag_facets = detect_tags(&text_processed); 224 224 + facet_candidates.extend(tag_facets); 225 225 + 226 226 + RichTextBuilder { 227 227 + text: text_processed, 228 228 + facet_candidates, 147 229 _state: PhantomData, 148 230 } 149 231 } ··· 408 490 facets 409 491 } 410 492 493 493 + /// Classifies a URL or at-URI as an embed candidate 494 494 + #[cfg(feature = "api_bluesky")] 495 495 + fn classify_embed(url: &str, embed_domains: &[&str]) -> Option<EmbedCandidate<'static>> { 496 496 + use crate::types::aturi::AtUri; 497 497 + 498 498 + // Check if it's an at:// URI 499 499 + if url.starts_with("at://") { 500 500 + if let Ok(at_uri) = AtUri::new(url) { 501 501 + return Some(EmbedCandidate::Record { 502 502 + at_uri: at_uri.into_static(), 503 503 + strong_ref: None, 504 504 + }); 505 505 + } 506 506 + } 507 507 + 508 508 + // Check if it's an HTTP(S) URL 509 509 + if url.starts_with("http://") || url.starts_with("https://") { 510 510 + // Try to extract at-uri from configured domain URL patterns 511 511 + if let Some(at_uri) = extract_at_uri_from_url(url, embed_domains) { 512 512 + return Some(EmbedCandidate::Record { 513 513 + at_uri, 514 514 + strong_ref: None, 515 515 + }); 516 516 + } 517 517 + 518 518 + // Otherwise, it's an external embed 519 519 + return Some(EmbedCandidate::External { 520 520 + url: CowStr::from(url.to_string()), 521 521 + metadata: None, 522 522 + }); 523 523 + } 524 524 + 525 525 + None 526 526 + } 527 527 + 528 528 + /// Extracts an at-URI from a URL with bsky.app-style path patterns 529 529 + /// 530 530 + /// Supports these patterns: 531 531 + /// - https://{domain}/profile/{handle|did}/post/{rkey} → at://{actor}/app.bsky.feed.post/{rkey} 532 532 + /// - https://{domain}/profile/{handle|did}/lists/{rkey} → at://{actor}/app.bsky.graph.list/{rkey} 533 533 + /// - https://{domain}/profile/{handle|did}/feed/{rkey} → at://{actor}/app.bsky.feed.generator/{rkey} 534 534 + /// - https://{domain}/starter-pack/{handle|did}/{rkey} → at://{actor}/app.bsky.graph.starterpack/{rkey} 535 535 + /// - https://{domain}/profile/{handle|did}/{collection}/{rkey} → at://{actor}/{collection}/{rkey} (if collection looks like NSID) 536 536 + /// 537 537 + /// Only works for domains in the provided `embed_domains` list. 538 538 + #[cfg(feature = "api_bluesky")] 539 539 + fn extract_at_uri_from_url( 540 540 + url: &str, 541 541 + embed_domains: &[&str], 542 542 + ) -> Option<crate::types::aturi::AtUri<'static>> { 543 543 + use crate::types::aturi::AtUri; 544 544 + 545 545 + // Parse URL 546 546 + let url_parsed = url::Url::parse(url).ok()?; 547 547 + 548 548 + // Check if domain is in allowed list 549 549 + let domain = url_parsed.domain()?; 550 550 + if !embed_domains.contains(&domain) { 551 551 + return None; 552 552 + } 553 553 + 554 554 + let path = url_parsed.path(); 555 555 + let segments: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect(); 556 556 + 557 557 + let at_uri_str = match segments.as_slice() { 558 558 + // Known shortcuts 559 559 + ["profile", actor, "post", rkey] => { 560 560 + format!("at://{}/app.bsky.feed.post/{}", actor, rkey) 561 561 + } 562 562 + ["profile", actor, "lists", rkey] => { 563 563 + format!("at://{}/app.bsky.graph.list/{}", actor, rkey) 564 564 + } 565 565 + ["profile", actor, "feed", rkey] => { 566 566 + format!("at://{}/app.bsky.feed.generator/{}", actor, rkey) 567 567 + } 568 568 + ["starter-pack", actor, rkey] => { 569 569 + format!("at://{}/app.bsky.graph.starterpack/{}", actor, rkey) 570 570 + } 571 571 + // Generic pattern: /profile/{actor}/{collection}/{rkey} 572 572 + // Accept if collection looks like it could be an NSID (contains dots) 573 573 + ["profile", actor, collection, rkey] if collection.contains('.') => { 574 574 + format!("at://{}/{}/{}", actor, collection, rkey) 575 575 + } 576 576 + _ => return None, 577 577 + }; 578 578 + 579 579 + AtUri::new(&at_uri_str).ok().map(|u| u.into_static()) 580 580 + } 581 581 + 411 582 use jacquard_common::types::string::AtStrError; 412 583 use thiserror::Error; 413 584 ··· 429 600 /// Invalid byte range 430 601 #[error("Invalid byte range {start}..{end} for text of length {text_len}")] 431 602 InvalidRange { 603 603 + /// Range start position 432 604 start: usize, 605 605 + /// Range end position 433 606 end: usize, 607 607 + /// Total text length 434 608 text_len: usize, 435 609 }, 436 610 ··· 446 620 #[cfg(feature = "api_bluesky")] 447 621 impl RichTextBuilder<Resolved> { 448 622 /// Build the richtext (sync - all facets must be resolved) 449 449 - pub fn build( 450 450 - self, 451 451 - ) -> Result< 452 452 - ( 453 453 - String, 454 454 - Option<Vec<crate::api::app_bsky::richtext::facet::Facet<'static>>>, 455 455 - ), 456 456 - RichTextError, 457 457 - > { 623 623 + pub fn build(self) -> Result<(String, Option<Vec<Facet<'static>>>), RichTextError> { 458 624 use std::collections::BTreeMap; 459 625 if self.facet_candidates.is_empty() { 460 626 return Ok((self.text, None)); ··· 475 641 let text_len = self.text.len(); 476 642 477 643 for candidate in candidates { 644 644 + use crate::api::app_bsky::richtext::facet::{ByteSlice, Facet}; 645 645 + 478 646 let (range, feature) = match candidate { 479 647 FacetCandidate::MarkdownLink { display_range, url } => { 480 648 // MarkdownLink stores URL directly, use display_range for index ··· 574 742 }); 575 743 } 576 744 577 577 - facets.push(crate::api::app_bsky::richtext::facet::Facet { 578 578 - index: crate::api::app_bsky::richtext::facet::ByteSlice { 745 745 + facets.push(Facet { 746 746 + index: ByteSlice { 747 747 + byte_start: range.start as i64, 748 748 + byte_end: range.end as i64, 749 749 + extra_data: BTreeMap::new(), 750 750 + }, 751 751 + features: vec![feature], 752 752 + extra_data: BTreeMap::new(), 753 753 + }); 754 754 + 755 755 + last_end = range.end; 756 756 + } 757 757 + 758 758 + Ok((self.text, Some(facets.into_static()))) 759 759 + } 760 760 + } 761 761 + 762 762 + #[cfg(feature = "api_bluesky")] 763 763 + impl RichTextBuilder<Unresolved> { 764 764 + /// Build richtext, resolving handles to DIDs using the provided resolver 765 765 + pub async fn build_async<R>( 766 766 + self, 767 767 + resolver: &R, 768 768 + ) -> Result<(String, Option<Vec<Facet<'static>>>), RichTextError> 769 769 + where 770 770 + R: jacquard_identity::resolver::IdentityResolver + Sync, 771 771 + { 772 772 + use crate::api::app_bsky::richtext::facet::{ 773 773 + ByteSlice, FacetFeaturesItem, Link, Mention, Tag, 774 774 + }; 775 775 + use std::collections::BTreeMap; 776 776 + 777 777 + if self.facet_candidates.is_empty() { 778 778 + return Ok((self.text, None)); 779 779 + } 780 780 + 781 781 + // Sort facets by start position 782 782 + let mut candidates = self.facet_candidates; 783 783 + candidates.sort_by_key(|fc| match fc { 784 784 + FacetCandidate::MarkdownLink { display_range, .. } => display_range.start, 785 785 + FacetCandidate::Mention { range, .. } => range.start, 786 786 + FacetCandidate::Link { range } => range.start, 787 787 + FacetCandidate::Tag { range } => range.start, 788 788 + }); 789 789 + 790 790 + // Resolve handles and convert to Facet types 791 791 + let mut facets = Vec::with_capacity(candidates.len()); 792 792 + let mut last_end = 0; 793 793 + let text_len = self.text.len(); 794 794 + 795 795 + for candidate in candidates { 796 796 + let (range, feature) = match candidate { 797 797 + FacetCandidate::MarkdownLink { display_range, url } => { 798 798 + // MarkdownLink stores URL directly, use display_range for index 799 799 + 800 800 + let feature = FacetFeaturesItem::Link(Box::new(Link { 801 801 + uri: crate::types::uri::Uri::new_owned(&url)?, 802 802 + extra_data: BTreeMap::new(), 803 803 + })); 804 804 + (display_range, feature) 805 805 + } 806 806 + FacetCandidate::Mention { range, did } => { 807 807 + let did = if let Some(did) = did { 808 808 + // Already resolved 809 809 + did 810 810 + } else { 811 811 + // Extract handle from text and resolve 812 812 + if range.end > text_len { 813 813 + return Err(RichTextError::InvalidRange { 814 814 + start: range.start, 815 815 + end: range.end, 816 816 + text_len, 817 817 + }); 818 818 + } 819 819 + 820 820 + let handle_str = self.text[range.clone()].trim_start_matches('@'); 821 821 + let handle = jacquard_common::types::handle::Handle::new(handle_str)?; 822 822 + 823 823 + resolver.resolve_handle(&handle).await? 824 824 + }; 825 825 + 826 826 + let feature = FacetFeaturesItem::Mention(Box::new(Mention { 827 827 + did, 828 828 + extra_data: BTreeMap::new(), 829 829 + })); 830 830 + (range, feature) 831 831 + } 832 832 + FacetCandidate::Link { range } => { 833 833 + // Extract URL from text[range] and normalize 834 834 + 835 835 + if range.end > text_len { 836 836 + return Err(RichTextError::InvalidRange { 837 837 + start: range.start, 838 838 + end: range.end, 839 839 + text_len, 840 840 + }); 841 841 + } 842 842 + 843 843 + let mut url = self.text[range.clone()].to_string(); 844 844 + 845 845 + // Prepend https:// if URL doesn't have a scheme 846 846 + if !url.starts_with("http://") && !url.starts_with("https://") { 847 847 + url = format!("https://{}", url); 848 848 + } 849 849 + 850 850 + let feature = FacetFeaturesItem::Link(Box::new(Link { 851 851 + uri: crate::types::uri::Uri::new_owned(&url)?, 852 852 + extra_data: BTreeMap::new(), 853 853 + })); 854 854 + (range, feature) 855 855 + } 856 856 + FacetCandidate::Tag { range } => { 857 857 + // Extract tag from text[range] (includes #), strip # and trailing punct 858 858 + 859 859 + use smol_str::ToSmolStr; 860 860 + if range.end > text_len { 861 861 + return Err(RichTextError::InvalidRange { 862 862 + start: range.start, 863 863 + end: range.end, 864 864 + text_len, 865 865 + }); 866 866 + } 867 867 + 868 868 + let tag_with_hash = &self.text[range.clone()]; 869 869 + // Strip # prefix (could be # or ＃) 870 870 + let tag = tag_with_hash 871 871 + .trim_start_matches('#') 872 872 + .trim_start_matches('＃'); 873 873 + 874 874 + let feature = FacetFeaturesItem::Tag(Box::new(Tag { 875 875 + tag: CowStr::from(tag.to_smolstr()), 876 876 + extra_data: BTreeMap::new(), 877 877 + })); 878 878 + (range, feature) 879 879 + } 880 880 + }; 881 881 + 882 882 + // Check overlap 883 883 + if range.start < last_end { 884 884 + return Err(RichTextError::OverlappingFacets(range.start, range.end)); 885 885 + } 886 886 + 887 887 + // Validate range 888 888 + if range.end > text_len { 889 889 + return Err(RichTextError::InvalidRange { 890 890 + start: range.start, 891 891 + end: range.end, 892 892 + text_len, 893 893 + }); 894 894 + } 895 895 + 896 896 + facets.push(Facet { 897 897 + index: ByteSlice { 579 898 byte_start: range.start as i64, 580 899 byte_end: range.end as i64, 581 900 extra_data: BTreeMap::new(),