cersei-tools 0.1.9

Tool trait, built-in tools, and permission system for the Cersei SDK
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

//! Plan mode tools: enter/exit read-only planning mode.

use super::*;
use std::sync::atomic::{AtomicBool, Ordering};

/// Global plan mode flag, shared across tool invocations.
static PLAN_MODE: AtomicBool = AtomicBool::new(false);

/// Check if plan mode is currently active.
pub fn is_plan_mode() -> bool {
    PLAN_MODE.load(Ordering::Relaxed)
}

/// Set plan mode state programmatically.
pub fn set_plan_mode(active: bool) {
    PLAN_MODE.store(active, Ordering::Relaxed);
}

pub struct EnterPlanModeTool;

#[async_trait]
impl Tool for EnterPlanModeTool {
    fn name(&self) -> &str {
        "EnterPlanMode"
    }
    fn description(&self) -> &str {
        "Enter plan mode: restricts to read-only tools for safe exploration and planning."
    }
    fn permission_level(&self) -> PermissionLevel {
        PermissionLevel::None
    }

    fn input_schema(&self) -> Value {
        serde_json::json!({
            "type": "object",
            "properties": {},
            "required": []
        })
    }

    async fn execute(&self, _input: Value, _ctx: &ToolContext) -> ToolResult {
        PLAN_MODE.store(true, Ordering::Relaxed);
        ToolResult::success("Plan mode activated. Only read-only tools are available.")
    }
}

pub struct ExitPlanModeTool;

#[async_trait]
impl Tool for ExitPlanModeTool {
    fn name(&self) -> &str {
        "ExitPlanMode"
    }
    fn description(&self) -> &str {
        "Exit plan mode and return to full tool access."
    }
    fn permission_level(&self) -> PermissionLevel {
        PermissionLevel::None
    }

    fn input_schema(&self) -> Value {
        serde_json::json!({
            "type": "object",
            "properties": {},
            "required": []
        })
    }

    async fn execute(&self, _input: Value, _ctx: &ToolContext) -> ToolResult {
        PLAN_MODE.store(false, Ordering::Relaxed);
        ToolResult::success("Plan mode deactivated. Full tool access restored.")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::permissions::AllowAll;
    use std::sync::Arc;

    fn test_ctx() -> ToolContext {
        ToolContext {
            working_dir: std::env::temp_dir(),
            session_id: "test".into(),
            permissions: Arc::new(AllowAll),
            cost_tracker: Arc::new(CostTracker::new()),
            mcp_manager: None,
            extensions: Extensions::default(),
        }
    }

    #[tokio::test]
    async fn test_plan_mode_toggle() {
        set_plan_mode(false);
        assert!(!is_plan_mode());

        let enter = EnterPlanModeTool;
        enter.execute(serde_json::json!({}), &test_ctx()).await;
        assert!(is_plan_mode());

        let exit = ExitPlanModeTool;
        exit.execute(serde_json::json!({}), &test_ctx()).await;
        assert!(!is_plan_mode());
    }
}