mobius-cli 0.9.10

The terminal client for a möbius gateway
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use super::*;

pub(super) fn rendered(block: FrontendBlock) -> RenderedBlock {
    RenderedBlock {
        capability: "test".into(),
        block,
    }
}

pub(super) fn recorded(
    event: EventMsg,
    blocks: Vec<RenderedBlock>,
    preview: Option<RenderedPreview>,
) -> RecordedEvent {
    RecordedEvent {
        sequence: 1,
        recorded_at_ms: 0,
        event: Event {
            submission_id: None,
            msg: event,
        },
        stream_metrics: Vec::new(),
        blocks,
        preview,
    }
}

pub(super) fn preview_record(
    id: &str,
    page_id: &str,
    update: FrontendPreviewUpdate,
    messages: &[&str],
    next: Option<Op>,
) -> RecordedEvent {
    recorded(
        EventMsg::ContextCompacted,
        Vec::new(),
        Some(RenderedPreview {
            id: id.into(),
            title: "agent".into(),
            subtitle: "complete · kimi/high · Full context".into(),
            page_id: page_id.into(),
            update,
            events: messages
                .iter()
                .map(|message| RenderedEvent {
                    recorded_at_ms: 0,
                    event: EventMsg::UserMessage(mobius::protocol::UserMessageEvent {
                        message: (*message).into(),
                        attachments: Vec::new(),
                        message_target: None,
                    }),
                    blocks: Vec::new(),
                })
                .collect(),
            next,
        }),
    )
}

pub(super) fn snapshot(state: &TuiState) -> &SnapshotPreview {
    let Some(PreviewState {
        content: PreviewContent::Snapshot(snapshot),
        ..
    }) = state.preview.as_ref()
    else {
        panic!("snapshot preview");
    };
    snapshot
}

pub(super) fn preview_messages(snapshot: &SnapshotPreview) -> Vec<&str> {
    snapshot
        .transcript
        .iter()
        .map(|entry| entry.text.as_str())
        .collect()
}

pub(super) fn preview_continuation(arguments: &str) -> Op {
    Op::CapabilityCommand {
        capability: "subagents".into(),
        command: "subagents".into(),
        arguments: arguments.into(),
        input: None,
        target: None,
    }
}

pub(super) fn catalog(workspace: &std::path::Path) -> UiCatalog {
    let steering = FrontendContribution {
        capability: "steering".into(),
        active_input: Some(FrontendActiveInput {
            operation: "steer".into(),
        }),
        ..FrontendContribution::default()
    };
    UiCatalog::build(
        &[steering],
        &[ModelChoice {
            route: "kimi".into(),
            group: "kimi".into(),
            model: "kimi-k3".into(),
            reasoning_effort: Some("high".into()),
            context_window: Some(1_048_576),
            supports_image_input: true,
        }],
        workspace,
    )
    .expect("UI catalog")
}

pub(super) fn default_catalog() -> UiCatalog {
    catalog(std::path::Path::new("/missing-mobius-test-workspace"))
}

pub(super) fn state() -> TuiState {
    TuiState::new(
        &default_catalog(),
        "/work/mobius".into(),
        ModelInfo {
            model: "kimi-k3".into(),
            reasoning_effort: Some("high".into()),
        },
        "kimi".into(),
        "MÖBIUS AGENT\nmodel: kimi-k3 · high".into(),
    )
}

pub(super) fn rendered_text(lines: &[ratatui::text::Line<'_>]) -> String {
    lines
        .iter()
        .map(|line| {
            line.spans
                .iter()
                .map(|span| span.content.as_ref())
                .collect::<String>()
        })
        .collect::<Vec<_>>()
        .join("\n")
}