Skip to main content

qualia_client_core/api/
agreements.rs

1//! Peer agreements
2
3#![allow(non_snake_case)]
4
5use super::*;
6
7use std::path::Path;
8
9/// All peer agreements.
10pub fn list_agreements() -> Result<serde_json::Value, String> {
11    serde_json::to_value(crate::agreements::list_agreements()).map_err(|e| e.to_string())
12}
13
14/// Agreements a DID is party to (or that govern its relationship) — fills the directory's agreement slot.
15pub fn agreements_for(did: String) -> Result<serde_json::Value, String> {
16    serde_json::to_value(crate::agreements::agreements_for(&did)).map_err(|e| e.to_string())
17}
18
19/// Create a new **draft** agreement for a relationship, grounded in the non-derogable values floor
20/// (defaults to UDHR), with a pending consent for each party. Returns the created agreement.
21pub fn create_agreement(
22    title: String,
23    relationship_did: String,
24    parties: Vec<String>,
25) -> Result<serde_json::Value, String> {
26    let now = mail_now_unix();
27    let a = crate::agreements::Agreement {
28        id: uuid::Uuid::new_v4().to_string(),
29        title,
30        relationship_did,
31        parties: parties.clone(),
32        values_anchors: vec!["urn:qualia:values:udhr".to_string()],
33        undertakings: vec![],
34        consents: parties
35            .into_iter()
36            .map(|did| crate::agreements::PartyConsent {
37                did,
38                consent: crate::agreements::ConsentState::Pending,
39                signature_hex: None,
40            })
41            .collect(),
42        stage: crate::agreements::FormationStage::Draft,
43        jurisdiction: None,
44        intents: Vec::new(),
45        artifact_context: None,
46        created_at: now,
47        updated_at: now,
48    };
49    crate::agreements::upsert_agreement(a.clone())?;
50    serde_json::to_value(a).map_err(|e| e.to_string())
51}
52
53/// Persist a full agreement (JSON) — for edits (undertakings, stage, etc.). Returns the refreshed list.
54pub fn save_agreement(agreement_json: String) -> Result<serde_json::Value, String> {
55    let a: crate::agreements::Agreement =
56        serde_json::from_str(&agreement_json).map_err(|e| format!("bad agreement: {e}"))?;
57    crate::agreements::upsert_agreement(a)?;
58    list_agreements()
59}
60
61/// Set a party's consent on an agreement (`state`: pending / granted / withdrawn).
62pub fn set_agreement_consent(
63    id: String,
64    did: String,
65    state: String,
66) -> Result<serde_json::Value, String> {
67    let mut all = crate::agreements::list_agreements();
68    let a = all
69        .iter_mut()
70        .find(|a| a.id == id)
71        .ok_or_else(|| format!("unknown agreement '{id}'"))?;
72    let cs = match state.to_lowercase().as_str() {
73        "granted" => crate::agreements::ConsentState::Granted,
74        "withdrawn" => crate::agreements::ConsentState::Withdrawn,
75        _ => crate::agreements::ConsentState::Pending,
76    };
77    crate::agreements::set_consent(a, &did, cs);
78    a.updated_at = mail_now_unix();
79    let updated = a.clone();
80    crate::agreements::upsert_agreement(updated)?;
81    list_agreements()
82}
83
84/// Gets chat-graph.
85pub fn get_chat_graph(session_id: String) -> Result<serde_json::Value, String> {
86    let state = crate::state::APP_STATE.get().unwrap();
87    let storage = state.config.lock().unwrap().storage_path.clone();
88    let graph = crate::chat_graph::load_graph(Path::new(&storage), &session_id)
89        .map_err(|e| e.to_string())?;
90    let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
91        .map_err(|e| e.to_string())?;
92    let reactions =
93        crate::chat_ontology::list_reactions(Path::new(&storage), &session_id).unwrap_or_default();
94    let branch_types = crate::chat_ontology::list_branch_types(Path::new(&storage));
95    serde_json::to_value(serde_json::json!({
96        "fragments": graph.fragments,
97        "edges": graph.edges,
98        "messages": session.messages,
99        "reactions": reactions,
100        "branch_types": branch_types,
101        "wordnet": crate::chat_ontology::resolve_wordnet_q42(Path::new(&storage))
102            .map(|p| p.to_string_lossy().to_string()),
103    }))
104    .map_err(|e| e.to_string())
105}
106
107/// Creates chat-fragment.
108pub fn create_chat_fragment(
109    session_id: String,
110    message_lamport: u64,
111    anchor_start: u32,
112    anchor_end: u32,
113) -> Result<serde_json::Value, String> {
114    let state = crate::state::APP_STATE.get().unwrap();
115    let storage = state.config.lock().unwrap().storage_path.clone();
116    let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
117        .map_err(|e| e.to_string())?;
118    let msg = session
119        .messages
120        .iter()
121        .find(|m| m.lamport == message_lamport)
122        .ok_or_else(|| format!("message {message_lamport} not found"))?;
123    let fragment = crate::chat_graph::create_fragment_from_selection(
124        Path::new(&storage),
125        &session_id,
126        message_lamport,
127        &msg.content,
128        anchor_start,
129        anchor_end,
130    )
131    .map_err(|e| e.to_string())?;
132    serde_json::to_value(fragment).map_err(|e| e.to_string())
133}
134
135/// Syncs the chat relay.
136pub fn sync_chat_relay(session_id: Option<String>) -> Result<u64, String> {
137    let state = crate::state::APP_STATE.get().unwrap();
138    let storage = state.config.lock().unwrap().storage_path.clone();
139    if let Some(id) = session_id {
140        Ok(crate::chat_relay::sync_session_relay(Path::new(&storage), &id)? as u64)
141    } else {
142        Ok(crate::chat_relay::sync_all_group_sessions()? as u64)
143    }
144}
145
146/// Starts the chat relay poller.
147pub fn start_chat_relay_poller() {
148    crate::chat_relay::start_relay_poller();
149}
150
151/// Lists chat branch types.
152pub fn list_chat_branch_types() -> Result<serde_json::Value, String> {
153    let state = crate::state::APP_STATE.get().unwrap();
154    let storage = state.config.lock().unwrap().storage_path.clone();
155    let types = crate::chat_ontology::list_branch_types(Path::new(&storage));
156    serde_json::to_value(types).map_err(|e| e.to_string())
157}
158
159/// Classifies a chat branch.
160pub fn classify_chat_branch(
161    anchor_text: String,
162    reply_text: String,
163) -> Result<serde_json::Value, String> {
164    let state = crate::state::APP_STATE.get().unwrap();
165    let storage = state.config.lock().unwrap().storage_path.clone();
166    let c = crate::chat_ontology::classify_branch(Path::new(&storage), &anchor_text, &reply_text);
167    serde_json::to_value(c).map_err(|e| e.to_string())
168}
169
170/// Toggles chat-reaction.
171pub fn toggle_chat_reaction(
172    session_id: String,
173    message_lamport: u64,
174    emoji: String,
175) -> Result<serde_json::Value, String> {
176    let state = crate::state::APP_STATE.get().unwrap();
177    let storage = state.config.lock().unwrap().storage_path.clone();
178    let reactions = crate::chat_ontology::toggle_reaction(
179        Path::new(&storage),
180        &session_id,
181        message_lamport,
182        &emoji,
183    )?;
184    serde_json::to_value(reactions).map_err(|e| e.to_string())
185}
186
187/// Lists chat reactions.
188pub fn list_chat_reactions(session_id: String) -> Result<serde_json::Value, String> {
189    let state = crate::state::APP_STATE.get().unwrap();
190    let storage = state.config.lock().unwrap().storage_path.clone();
191    let reactions = crate::chat_ontology::list_reactions(Path::new(&storage), &session_id)?;
192    serde_json::to_value(reactions).map_err(|e| e.to_string())
193}
194
195/// WordNet chat-ontology status.
196pub fn wordnet_chat_ontology_status() -> Result<serde_json::Value, String> {
197    let state = crate::state::APP_STATE.get().unwrap();
198    let storage = state.config.lock().unwrap().storage_path.clone();
199    let path = crate::chat_ontology::resolve_wordnet_q42(Path::new(&storage));
200    Ok(serde_json::json!({
201        "available": path.is_some(),
202        "q42_path": path.as_ref().map(|p| p.to_string_lossy().to_string()),
203        "lex_path": path.as_ref().and_then(|p| crate::chat_ontology::resolve_wordnet_lex(p).map(|l| l.to_string_lossy().to_string())),
204    }))
205}
206
207/// Default chat-file sharing.
208pub fn default_chat_file_sharing(session_id: String) -> Result<serde_json::Value, String> {
209    let state = crate::state::APP_STATE.get().unwrap();
210    let storage = state.config.lock().unwrap().storage_path.clone();
211    let session = crate::chat_session::load_session(Path::new(&storage), &session_id)
212        .map_err(|e| e.to_string())?;
213    let sharing = crate::chat_files::default_sharing_for_session(session.meta.session_kind);
214    serde_json::to_value(sharing).map_err(|e| e.to_string())
215}
216
217/// Attaches a file to a chat.
218pub fn attach_chat_file(
219    session_id: String,
220    source_path: String,
221    sharing_json: serde_json::Value,
222) -> Result<serde_json::Value, String> {
223    let state = crate::state::APP_STATE.get().unwrap();
224    let storage = state.config.lock().unwrap().storage_path.clone();
225    let sharing: crate::chat_files::ChatFileSharing =
226        serde_json::from_value(sharing_json).map_err(|e| e.to_string())?;
227    let result = crate::chat_files::attach_chat_file(
228        Path::new(&storage),
229        &session_id,
230        Path::new(&source_path),
231        sharing,
232    )?;
233    serde_json::to_value(result).map_err(|e| e.to_string())
234}
235
236/// Lists chat files.
237pub fn list_chat_files(session_id: String) -> Result<serde_json::Value, String> {
238    let state = crate::state::APP_STATE.get().unwrap();
239    let storage = state.config.lock().unwrap().storage_path.clone();
240    let files = crate::chat_files::list_chat_files(Path::new(&storage), &session_id, None)?;
241    serde_json::to_value(files).map_err(|e| e.to_string())
242}
243
244/// Sets chat-file-sharing.
245pub fn set_chat_file_sharing(
246    session_id: String,
247    file_id: String,
248    sharing_json: serde_json::Value,
249) -> Result<serde_json::Value, String> {
250    let state = crate::state::APP_STATE.get().unwrap();
251    let storage = state.config.lock().unwrap().storage_path.clone();
252    let sharing: crate::chat_files::ChatFileSharing =
253        serde_json::from_value(sharing_json).map_err(|e| e.to_string())?;
254    let updated = crate::chat_files::set_chat_file_sharing(
255        Path::new(&storage),
256        &session_id,
257        &file_id,
258        sharing,
259    )?;
260    serde_json::to_value(updated).map_err(|e| e.to_string())
261}
262
263/// Gets chat-file-local-path.
264pub fn get_chat_file_local_path(
265    session_id: String,
266    file_id: String,
267    variant: String,
268) -> Result<String, String> {
269    let state = crate::state::APP_STATE.get().unwrap();
270    let storage = state.config.lock().unwrap().storage_path.clone();
271    let path = crate::chat_files::resolve_chat_file_path(
272        Path::new(&storage),
273        &session_id,
274        &file_id,
275        &variant,
276        None,
277    )?;
278    Ok(path.to_string_lossy().to_string())
279}
280
281/// Parses chat-file-preview.
282pub fn parse_chat_file_preview(source_path: String) -> Result<serde_json::Value, String> {
283    let path = Path::new(&source_path);
284    if !path.is_file() {
285        return Err(format!("File not found: {}", path.display()));
286    }
287    let mut bytes = Vec::new();
288    std::fs::File::open(path)
289        .and_then(|mut f| std::io::Read::read_to_end(&mut f, &mut bytes))
290        .map_err(|e| e.to_string())?;
291    let name = path.file_name().and_then(|s| s.to_str()).unwrap_or("file");
292    let parsed = crate::chat_files::parse_document_bytes(name, &bytes);
293    serde_json::to_value(parsed).map_err(|e| e.to_string())
294}