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

//! Atlas's CLI grammar and text projection. Rust callers use [`super::Store`]
//! directly; MCP has its own typed argument boundary in [`super::mcp`].

use anyhow::{bail, Result};

use super::{render, Store};
use crate::out::Out;
use crate::spec::{Invocation, Param, Spec, Verb};

pub static SPEC: Spec = Spec {
    name: "atlas",
    about: "Schema metadata inspection faculty",
    version: Some(crate::GIT_VERSION),
    shared: &[
        Param::caller("pile", "Path to the pile file to use")
            .path()
            .ambient()
            .env("PILE"),
        Param::caller(
            "key",
            "Existing durable signing-key file. Reads and writes never create it.",
        )
        .path()
        .ambient()
        .optional()
        .env("TRIBLESPACE_KEY"),
    ],
    verbs: &[
        Verb {
            name: "list",
            about: "List entities that have metadata::name entries",
            params: &[],
        },
        Verb {
            name: "show",
            about: "Show metadata for a single id prefix",
            params: &[Param::caller("id", "Entity id or unique prefix").positional()],
        },
    ],
};

/// Execute a parsed CLI request. Output routing belongs to `crate::cli`.
pub fn execute(invocation: &Invocation, output: &mut Out<'_>) -> Result<()> {
    let store = Store::open(invocation.require_path("pile")?, invocation.path("key"))?;
    let result = (|| {
        match invocation.verb().name {
            "list" => {
                for row in store.list()? {
                    output.line(render::list_line(&row))?;
                }
            }
            "show" => {
                for line in render::show_lines(&store.show(invocation.require("id")?)?) {
                    output.line(line)?;
                }
            }
            other => bail!("Atlas CLI has no verb {other:?}"),
        }
        Ok(())
    })();
    store.finish(result)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn cli_retains_the_atlas_surface() {
        let command = SPEC.to_clap();
        assert_eq!(command.get_version(), Some(crate::GIT_VERSION));
        assert_eq!(
            command
                .get_subcommands()
                .map(|command| command.get_name())
                .collect::<Vec<_>>(),
            ["list", "show"]
        );
        for forbidden in ["scope", "branch", "branch_id", "head", "repair"] {
            assert!(!command
                .get_arguments()
                .any(|argument| argument.get_id() == forbidden));
        }
        assert!(command
            .get_arguments()
            .any(|argument| argument.get_id() == "key"));
    }
}