collet 0.1.1

Relentless agentic coding orchestrator with zero-drop agent loops
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

//! Sidebar info (MCP/LSP status) and approve-mode REST endpoints.

use std::sync::Arc;

use axum::Router;
use axum::extract::State;
use axum::http::StatusCode;
use axum::response::Json;
use axum::routing::get;
use serde::{Deserialize, Serialize};

use crate::agent::approval::ApproveMode;
use crate::lsp::client::known_servers;

use super::state::AppState;

pub fn router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/api/sidebar", get(sidebar_info))
        .route("/api/approve-mode", get(get_approve_mode))
        .route("/api/approve-mode", axum::routing::patch(set_approve_mode))
}

// ── Sidebar ──────────────────────────────────────────────────────────────────

#[derive(Serialize)]
struct McpServerInfo {
    name: String,
    available: bool,
}

#[derive(Serialize)]
struct LspServerInfo {
    name: String,
    available: bool,
}

#[derive(Serialize)]
struct SidebarResponse {
    mcp_servers: Vec<McpServerInfo>,
    lsp_servers: Vec<LspServerInfo>,
}

async fn sidebar_info(State(state): State<Arc<AppState>>) -> Json<SidebarResponse> {
    let working_dir = state.working_dir().await;

    // MCP servers from config
    let mcp_servers = crate::mcp::config::load_mcp_status(&working_dir)
        .into_iter()
        .map(|s| McpServerInfo {
            available: matches!(s.status, crate::mcp::config::McpStatus::Available),
            name: s.name,
        })
        .collect();

    // LSP servers installed on system
    let lsp_servers = known_servers()
        .into_iter()
        .filter(|s| {
            std::process::Command::new("which")
                .arg(&s.command)
                .output()
                .map(|o| o.status.success())
                .unwrap_or(false)
        })
        .map(|s| LspServerInfo {
            name: s.command.clone(),
            available: true,
        })
        .collect();

    Json(SidebarResponse {
        mcp_servers,
        lsp_servers,
    })
}

// ── Approve mode ─────────────────────────────────────────────────────────────

#[derive(Serialize)]
struct ApproveModeResponse {
    mode: String,
}

async fn get_approve_mode(State(state): State<Arc<AppState>>) -> Json<ApproveModeResponse> {
    Json(ApproveModeResponse {
        mode: state.approve_mode.get().to_string(),
    })
}

#[derive(Deserialize)]
struct SetApproveModeRequest {
    mode: String,
}

async fn set_approve_mode(
    State(state): State<Arc<AppState>>,
    Json(req): Json<SetApproveModeRequest>,
) -> Result<Json<ApproveModeResponse>, (StatusCode, String)> {
    let mode = req.mode.parse::<ApproveMode>().map_err(|_| {
        (
            StatusCode::BAD_REQUEST,
            format!("Invalid mode '{}'. Use: yolo, auto, manual", req.mode),
        )
    })?;
    state.approve_mode.set(mode);
    Ok(Json(ApproveModeResponse {
        mode: state.approve_mode.get().to_string(),
    }))
}