Skip to main content

qualia_client_core/
project_collab.rs

1//! Lightweight **cooperative project registry + collaborator roster** for Talk → Projects.
2//!
3//! Works **without** an unlocked Sanctuary vault so cooperative help is not blocked on first-run
4//! vault setup. When the vault *is* unlocked, Wellfair journal membership remains the durable
5//! clinical/ledger path; this module is the always-available social roster and local project list.
6
7use serde::{Deserialize, Serialize};
8use std::collections::BTreeMap;
9use std::fs;
10use std::path::PathBuf;
11
12use crate::state::app_meta_dir;
13
14#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
15pub struct ProjectCollaborator {
16    pub project_id: String,
17    pub project_name: String,
18    pub member_did: String,
19    #[serde(default)]
20    pub display_name: String,
21    /// `steward` | `contributor` | `observer` | `agent`
22    pub role: String,
23    pub added_at: u64,
24}
25
26/// A cooperative project that exists on this device (local-first; vault optional).
27#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
28pub struct LocalProject {
29    pub id: String,
30    pub name: String,
31    #[serde(default)]
32    pub description: String,
33    pub created_at: u64,
34    /// `local` = created here without vault; `wellfair` = also mirrored to vault journal when unlocked.
35    #[serde(default = "default_source_local")]
36    pub source: String,
37}
38
39fn default_source_local() -> String {
40    "local".into()
41}
42
43/// Summary row for the Projects UI.
44#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
45pub struct ProjectSummary {
46    pub id: String,
47    pub name: String,
48    pub member_count: usize,
49    pub source: String,
50}
51
52fn path() -> PathBuf {
53    app_meta_dir().join("project_collaborators.json")
54}
55
56fn projects_path() -> PathBuf {
57    app_meta_dir().join("coop_projects.json")
58}
59
60fn load() -> Vec<ProjectCollaborator> {
61    fs::read_to_string(path())
62        .ok()
63        .and_then(|t| serde_json::from_str(&t).ok())
64        .unwrap_or_default()
65}
66
67fn save(rows: &[ProjectCollaborator]) -> Result<(), String> {
68    let p = path();
69    if let Some(parent) = p.parent() {
70        fs::create_dir_all(parent).map_err(|e| e.to_string())?;
71    }
72    fs::write(
73        p,
74        serde_json::to_string_pretty(rows).map_err(|e| e.to_string())?,
75    )
76    .map_err(|e| e.to_string())
77}
78
79fn now() -> u64 {
80    std::time::SystemTime::now()
81        .duration_since(std::time::UNIX_EPOCH)
82        .map(|d| d.as_secs())
83        .unwrap_or(0)
84}
85
86/// List collaborators, optionally filtered to one project id.
87pub fn list(project_id: Option<&str>) -> Vec<ProjectCollaborator> {
88    let all = load();
89    match project_id {
90        Some(id) if !id.is_empty() => all.into_iter().filter(|c| c.project_id == id).collect(),
91        _ => all,
92    }
93}
94
95/// Upsert a collaborator on a project (keyed by project_id + member_did).
96pub fn add(
97    project_id: &str,
98    project_name: &str,
99    member_did: &str,
100    display_name: &str,
101    role: &str,
102) -> Result<ProjectCollaborator, String> {
103    let project_id = project_id.trim();
104    let member_did = member_did.trim();
105    if project_id.is_empty() || member_did.is_empty() {
106        return Err("project_id and member_did are required".into());
107    }
108    let role = match role.trim().to_ascii_lowercase().as_str() {
109        "steward" => "steward",
110        "observer" => "observer",
111        "agent" => "agent",
112        _ => "contributor",
113    };
114    let mut all = load();
115    all.retain(|c| !(c.project_id == project_id && c.member_did == member_did));
116    let row = ProjectCollaborator {
117        project_id: project_id.to_string(),
118        project_name: project_name.trim().to_string(),
119        member_did: member_did.to_string(),
120        display_name: display_name.trim().to_string(),
121        role: role.to_string(),
122        added_at: now(),
123    };
124    all.push(row.clone());
125    save(&all)?;
126    Ok(row)
127}
128
129/// Removes.
130pub fn remove(project_id: &str, member_did: &str) -> Result<(), String> {
131    let mut all = load();
132    let before = all.len();
133    all.retain(|c| !(c.project_id == project_id && c.member_did == member_did));
134    if all.len() == before {
135        return Err("collaborator not found".into());
136    }
137    save(&all)
138}
139
140fn load_projects() -> Vec<LocalProject> {
141    fs::read_to_string(projects_path())
142        .ok()
143        .and_then(|t| serde_json::from_str(&t).ok())
144        .unwrap_or_default()
145}
146
147fn save_projects(rows: &[LocalProject]) -> Result<(), String> {
148    let p = projects_path();
149    if let Some(parent) = p.parent() {
150        fs::create_dir_all(parent).map_err(|e| e.to_string())?;
151    }
152    fs::write(
153        p,
154        serde_json::to_string_pretty(rows).map_err(|e| e.to_string())?,
155    )
156    .map_err(|e| e.to_string())
157}
158
159/// Create (or upsert by name) a **local** cooperative project — no vault required.
160pub fn create_local_project(name: &str, description: &str) -> Result<LocalProject, String> {
161    let name = name.trim();
162    if name.is_empty() {
163        return Err("project name is required".into());
164    }
165    let mut all = load_projects();
166    if let Some(existing) = all.iter().find(|p| p.name.eq_ignore_ascii_case(name)) {
167        return Ok(existing.clone());
168    }
169    let id = format!("local-{}", now());
170    let proj = LocalProject {
171        id: id.clone(),
172        name: name.to_string(),
173        description: description.trim().to_string(),
174        created_at: now(),
175        source: "local".into(),
176    };
177    all.push(proj.clone());
178    save_projects(&all)?;
179    // Steward: local profile DID when available.
180    let profile = crate::user_profile::load_profile();
181    let self_did = if profile.public_did.is_empty() {
182        crate::user_profile::resolve_public_did(&profile)
183    } else {
184        profile.public_did.clone()
185    };
186    if !self_did.is_empty() {
187        let _ = add(&id, name, &self_did, &profile.display_name, "steward");
188    }
189    Ok(proj)
190}
191
192/// Register a wellfair-backed project id into the local registry (after vault create).
193pub fn register_wellfair_project(
194    id: &str,
195    name: &str,
196    description: &str,
197) -> Result<LocalProject, String> {
198    let id = id.trim();
199    let name = name.trim();
200    if id.is_empty() || name.is_empty() {
201        return Err("id and name required".into());
202    }
203    let mut all = load_projects();
204    all.retain(|p| p.id != id);
205    let proj = LocalProject {
206        id: id.to_string(),
207        name: name.to_string(),
208        description: description.trim().to_string(),
209        created_at: now(),
210        source: "wellfair".into(),
211    };
212    all.push(proj.clone());
213    save_projects(&all)?;
214    Ok(proj)
215}
216
217/// List projects for the UI: local registry + any ids seen only in the collaborator roster.
218pub fn list_project_summaries() -> Vec<ProjectSummary> {
219    let mut by_id: BTreeMap<String, ProjectSummary> = BTreeMap::new();
220    for p in load_projects() {
221        let n = list(Some(&p.id)).len();
222        by_id.insert(
223            p.id.clone(),
224            ProjectSummary {
225                id: p.id,
226                name: p.name,
227                member_count: n,
228                source: p.source,
229            },
230        );
231    }
232    for c in load() {
233        by_id
234            .entry(c.project_id.clone())
235            .and_modify(|s| {
236                if s.name.is_empty() && !c.project_name.is_empty() {
237                    s.name = c.project_name.clone();
238                }
239                // recount below
240            })
241            .or_insert_with(|| ProjectSummary {
242                id: c.project_id.clone(),
243                name: if c.project_name.is_empty() {
244                    c.project_id.clone()
245                } else {
246                    c.project_name.clone()
247                },
248                member_count: 0,
249                source: "roster".into(),
250            });
251    }
252    // Final member counts
253    for s in by_id.values_mut() {
254        s.member_count = list(Some(&s.id)).len();
255    }
256    let mut out: Vec<_> = by_id.into_values().collect();
257    out.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
258    out
259}
260
261#[cfg(test)]
262mod tests {
263    use super::*;
264
265    #[test]
266    fn add_list_remove() {
267        let pid = format!("board-test-{}", now());
268        let did = format!("did:test:{}", now());
269        let row = add(&pid, "Test Project", &did, "Alice", "contributor").expect("add");
270        assert_eq!(row.project_id, pid);
271        assert!(list(Some(&pid)).iter().any(|c| c.member_did == did));
272        remove(&pid, &did).expect("remove");
273        assert!(!list(Some(&pid)).iter().any(|c| c.member_did == did));
274    }
275
276    #[test]
277    fn create_local_project_and_summaries() {
278        let name = format!("CoopTest-{}", now());
279        let p = create_local_project(&name, "desc").expect("create");
280        assert!(!p.id.is_empty());
281        let again = create_local_project(&name, "desc").expect("idempotent");
282        assert_eq!(p.id, again.id);
283        let sums = list_project_summaries();
284        assert!(sums.iter().any(|s| s.name == name));
285    }
286}