outrig-cli 0.1.0

Command-line tool for running LLM agents with podman-isolated MCP servers.
Documentation 
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

use serde::Serialize;

#[derive(Debug, Clone, Copy)]
pub struct Doc {
    pub page: &'static str,
    pub markdown: &'static str,
}

#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub struct DocSummary {
    pub page: &'static str,
    pub title: String,
    pub summary: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct DocList {
    pub docs: Vec<DocSummary>,
}

#[derive(Debug, Clone, Serialize)]
pub struct DocContent {
    pub page: &'static str,
    pub markdown: &'static str,
}

pub const DOCS: &[Doc] = &[
    Doc {
        page: "concepts/containers",
        markdown: include_str!("docs/concepts/containers.md"),
    },
    Doc {
        page: "concepts/mcp-servers",
        markdown: include_str!("docs/concepts/mcp-servers.md"),
    },
    Doc {
        page: "concepts/mcp-trust-model",
        markdown: include_str!("docs/concepts/mcp-trust-model.md"),
    },
    Doc {
        page: "concepts/workspace",
        markdown: include_str!("docs/concepts/workspace.md"),
    },
    Doc {
        page: "reference/config",
        markdown: include_str!("docs/reference/config.md"),
    },
    Doc {
        page: "usage/ai-assisted-design",
        markdown: include_str!("docs/usage/ai-assisted-design.md"),
    },
    Doc {
        page: "usage/image",
        markdown: include_str!("docs/usage/image.md"),
    },
];

pub fn list_docs() -> DocList {
    DocList {
        docs: DOCS.iter().map(summarize).collect(),
    }
}

pub fn get_doc(page: &str) -> Option<DocContent> {
    DOCS.iter()
        .find(|doc| doc.page == page)
        .map(|doc| DocContent {
            page: doc.page,
            markdown: doc.markdown,
        })
}

fn summarize(doc: &Doc) -> DocSummary {
    let title = doc
        .markdown
        .lines()
        .find_map(|line| line.strip_prefix("# "))
        .unwrap_or(doc.page)
        .trim()
        .to_string();
    let summary = doc
        .markdown
        .lines()
        .map(str::trim)
        .filter(|line| {
            !line.is_empty()
                && !line.starts_with('#')
                && !line.starts_with('>')
                && !line.starts_with("```")
        })
        .find(|line| *line != title)
        .unwrap_or("")
        .to_string();

    DocSummary {
        page: doc.page,
        title,
        summary,
    }
}

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

    #[test]
    fn list_includes_trust_model() {
        let list = list_docs();
        assert!(
            list.docs
                .iter()
                .any(|doc| doc.page == "concepts/mcp-trust-model"),
            "doc list should include the trust model: {:?}",
            list.docs,
        );
    }

    #[test]
    fn get_doc_returns_markdown() {
        let doc = get_doc("concepts/containers").expect("containers doc exists");
        assert!(doc.markdown.starts_with("# Containers"));
    }
}