rpi-cli 0.1.11

Terminal coding-agent CLI (the `rpi` binary) built on the rpi-* library crates — a Rust port of @earendil-works/pi-coding-agent's CLI surface
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

//! Stable capability contracts shared by native and Node extension backends.
//!
//! The CLI consumes extension metadata through these small contracts instead
//! of depending on the implementation (cdylib or Node/RPC). New backends can
//! opt into capabilities without changing the TUI or agent orchestration.

use std::collections::BTreeSet;

pub const EXTENSION_API_VERSION: u32 = 1;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ExtensionCapability {
    Tools,
    Commands,
    Resources,
    UiNotify,
    UiEditor,
    UiCustom,
    UiSelect,
    UiConfirm,
    UiInput,
    UiEditorDialog,
    Session,
    Models,
    Events,
    Providers,
    ProviderCalls,
    Renderers,
    RuntimeActions,
}

impl ExtensionCapability {
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Tools => "tools",
            Self::Commands => "commands",
            Self::Resources => "resources",
            Self::UiNotify => "ui.notify",
            Self::UiEditor => "ui.editor",
            Self::UiCustom => "ui.custom",
            Self::UiSelect => "ui.select",
            Self::UiConfirm => "ui.confirm",
            Self::UiInput => "ui.input",
            Self::UiEditorDialog => "ui.editor_dialog",
            Self::Session => "session",
            Self::Models => "models",
            Self::Events => "events",
            Self::Providers => "providers",
            Self::ProviderCalls => "provider_calls",
            Self::Renderers => "renderers",
            Self::RuntimeActions => "runtime_actions",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExtensionBackendInfo {
    pub name: &'static str,
    pub api_version: u32,
    pub capabilities: BTreeSet<ExtensionCapability>,
}

impl ExtensionBackendInfo {
    pub fn new(name: &'static str) -> Self {
        Self {
            name,
            api_version: EXTENSION_API_VERSION,
            capabilities: BTreeSet::new(),
        }
    }

    pub fn with_capabilities(
        name: &'static str,
        capabilities: impl IntoIterator<Item = ExtensionCapability>,
    ) -> Self {
        Self {
            name,
            api_version: EXTENSION_API_VERSION,
            capabilities: capabilities.into_iter().collect(),
        }
    }

    pub fn supports(&self, capability: ExtensionCapability) -> bool {
        self.capabilities.contains(&capability)
    }

    pub fn capability_names(&self) -> Vec<&'static str> {
        self.capabilities
            .iter()
            .map(|capability| capability.as_str())
            .collect()
    }
}

/// Common metadata contract implemented by every extension backend.
pub trait ExtensionBackend {
    fn backend_info(&self) -> ExtensionBackendInfo;
}

/// Capabilities currently provided by the Rust-native cdylib backend.
pub fn native_backend_info() -> ExtensionBackendInfo {
    ExtensionBackendInfo::with_capabilities(
        "native-rust",
        [
            ExtensionCapability::Tools,
            ExtensionCapability::Commands,
            ExtensionCapability::Resources,
            ExtensionCapability::Session,
            ExtensionCapability::Models,
            ExtensionCapability::Events,
            ExtensionCapability::Providers,
            ExtensionCapability::ProviderCalls,
            ExtensionCapability::Renderers,
            ExtensionCapability::RuntimeActions,
        ],
    )
}

impl ExtensionBackend for rpi_extensions::ExtensionSession {
    fn backend_info(&self) -> ExtensionBackendInfo {
        native_backend_info()
    }
}