faculties 0.21.0

An office suite for AI agents: kanban, wiki, files, messaging, and a Lissajous-backed viewer — all persisted in a TribleSpace pile.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Teams presentation shared where the frontend semantics really agree.
use super::operations::*;
use crate::out::Out;
use anyhow::Result;

pub fn context_banner(context: &PresentationContext) -> String {
    let name = context
        .name
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty());
    let boundary = context
        .boundary
        .as_deref()
        .map(str::trim)
        .filter(|value| !value.is_empty());
    let title = match name {
        Some(name) => format!("TEAMS · PRESENT AS {name} · PROFESSIONAL WORK CONTEXT"),
        None => "TEAMS · CONTEXT UNSET".to_owned(),
    };
    format!("{title}\nBOUNDARY · {}\n", boundary.unwrap_or("UNSET"))
}

pub fn activity<T>(value: &Activity<T>, out: &mut Out<'_>) -> Result<()> {
    out.text(context_banner(&value.context))?;
    for notice in &value.notices {
        out.line(notice)?;
    }
    Ok(())
}

pub fn context(value: &PresentationContext, out: &mut Out<'_>) -> Result<()> {
    out.line(format!(
        "present_as: {}",
        value.name.as_deref().unwrap_or("(unset)")
    ))?;
    out.line("context: professional/work-only")?;
    out.line(format!(
        "boundary: {}",
        value.boundary.as_deref().unwrap_or("(unset)")
    ))
}

pub fn messages(values: &[ArchivedMessage], out: &mut Out<'_>) -> Result<()> {
    for message in values {
        out.line(format!(
            "[{}] ({}) {}: {}",
            format_interval(message.created_at),
            message.chat,
            message.author,
            message.content
        ))?;
    }
    Ok(())
}

pub fn users(values: &[DirectoryUser], out: &mut Out<'_>) -> Result<()> {
    for user in values {
        out.line(format!("{}  {}  {}", user.id, user.name, user.contact))?;
    }
    Ok(())
}

pub fn presence(values: &[Presence], out: &mut Out<'_>) -> Result<()> {
    for value in values {
        out.line(format!(
            "{}  {}  {}",
            value.id, value.availability, value.activity
        ))?;
    }
    Ok(())
}

pub fn attachments(values: &[AttachmentInfo], out: &mut Out<'_>) -> Result<()> {
    for row in values {
        out.line(format!(
            "[{}] ({}) msg={} attachment={} name={} mime={} size={} source={}",
            format_interval(row.created_at),
            row.chat,
            row.message,
            row.reference,
            row.name.as_deref().unwrap_or("-"),
            row.media_type.as_deref().unwrap_or("-"),
            row.size
                .map(|size| size.to_string())
                .as_deref()
                .unwrap_or("-"),
            if row.source_pointers.is_empty() {
                "-".to_owned()
            } else {
                row.source_pointers.join(" | ")
            }
        ))?;
    }
    Ok(())
}

pub fn attachment_missing(reference: &str, out: &mut Out<'_>) -> Result<()> {
    out.line(format!("No stored attachment bytes found for {reference}."))
}

pub fn attachment_matches(matches: &[AttachmentMatch], out: &mut Out<'_>) -> Result<()> {
    for value in matches {
        out.line(format!(
            "- chat={} message={} attachment={}",
            value.chat, value.message, value.reference
        ))?;
    }
    Ok(())
}

pub fn auth_set(receipt: &AuthSet, out: &mut Out<'_>) -> Result<()> {
    out.line(format!("auth_profile: {:x}", receipt.profile))
}

pub fn login(receipt: &LoginReceipt, out: &mut Out<'_>) -> Result<()> {
    out.line(format!("auth_profile: {:x}", receipt.profile))?;
    out.line(format!(
        "delegated_token_version: {:x}",
        receipt.delegated_token_version
    ))?;
    if let Some(version) = receipt.client_secret_version {
        out.line(format!("client_secret_version: {version:x}"))?;
    }
    Ok(())
}