litecode 0.1.1

An ultra-lightweight Coding MCP server built with Rust
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

use std::{borrow::Cow, sync::Arc};

use rmcp::{
    ErrorData,
    handler::server::router::tool::{AsyncTool, ToolBase},
    model::JsonObject,
};

use crate::{
    schema::{TaskOutputInput, TaskOutputResponse},
    server::LiteCodeServer,
};

pub struct TaskOutputTool;

impl ToolBase for TaskOutputTool {
    type Parameter = TaskOutputInput;
    type Output = TaskOutputResponse;
    type Error = ErrorData;

    fn name() -> Cow<'static, str> {
        "TaskOutput".into()
    }

    fn description() -> Option<Cow<'static, str>> {
        Some(
            r#"- Retrieves output from a running or completed background shell task
- Takes a task_id parameter identifying the task
- Returns the task output along with status information
- Use block=true (default) to wait for task completion
- Use block=false for non-blocking check of current status
- Task IDs can be found using the /tasks command
- Works with background shell tasks started by the Bash tool"#
                .into(),
        )
    }

    fn input_schema() -> Option<Arc<JsonObject>> {
        Some(Arc::new(
            serde_json::json!({
                "type": "object",
                "properties": {
                    "task_id": {
                        "description": "The task ID to get output from",
                        "type": "string"
                    },
                    "block": {
                        "description": "Whether to wait for completion",
                        "default": true,
                        "type": "boolean"
                    },
                    "timeout": {
                        "description": "Max wait time in ms",
                        "default": 30000,
                        "type": "number",
                        "minimum": 0,
                        "maximum": 600000
                    }
                },
                "required": ["task_id", "block", "timeout"],
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "additionalProperties": false
            })
            .as_object()
            .expect("task output schema object")
            .clone(),
        ))
    }

    fn output_schema() -> Option<Arc<JsonObject>> {
        None
    }
}

impl AsyncTool<LiteCodeServer> for TaskOutputTool {
    async fn invoke(
        service: &LiteCodeServer,
        input: Self::Parameter,
    ) -> Result<Self::Output, Self::Error> {
        service
            .task_manager()
            .task_output(input)
            .await
            .map_err(Into::into)
    }
}