Coverage / src/cli/auto.rs 36.7%

pub fn agents_dir() -> PathBuf {

    if let Some(d) = std::env::var_os("SPECTRA_AGENTS").filter(|d| !d.is_empty()) {

        return PathBuf::from(d);

    }

    std::env::var_os("HOME").map(PathBuf::from).unwrap_or_default().join(".spectra-agents")

}

fn read_label(home: &Path) -> Option<Label> {

    let t: toml::Table = std::fs::read_to_string(home.join("agent.toml")).ok()?.parse().ok()?;

    let s = |k: &str| t.get(k).and_then(|v| v.as_str()).map(String::from);

    s("project")?;

    Some(Label { name: s("name")?, kind: s("kind")?, folder: s("folder").map(PathBuf::from), home: home.to_path_buf() })

}

async fn learn_label(endpoint: &spectra_mcp::client::Endpoint, home: &Path) -> Option<Label> {

    let key = KeyPair::load_home(home).ok()?;

    let c = Client::at(endpoint.clone(), Some(key.clone()));

    let agents = c.send("GET", "/api/v1/agents", &[], vec![]).await.ok()?.json().ok()?;

    let me = agents.as_array()?.iter().find(|a| a["key"] == key.key.to_hex())?.clone();

    let projects = c.send("GET", "/api/v1/projects", &[], vec![]).await.ok()?.json().ok()?;

    let project = me["project"].as_str()?.to_string();

    let folder = projects.as_array()?.iter().find(|p| p["name"] == project.as_str()).and_then(|p| p["path"].as_str().map(String::from));

    let (name, kind) = (me["name"].as_str()?.to_string(), me["kind"].as_str()?.to_string());

    let _ = write_label(home, &name, &kind, &project, folder.as_deref());

    Some(Label { name, kind, folder: folder.map(PathBuf::from), home: home.to_path_buf() })

}

pub async fn labels(endpoint: Option<&spectra_mcp::client::Endpoint>) -> Vec<Label> {

    let mut out = Vec::new();

    let Ok(dirs) = std::fs::read_dir(agents_dir()) else { return out };

    for d in dirs.filter_map(|e| e.ok()).map(|e| e.path()).filter(|p| p.join("keys").is_dir()) {

        match read_label(&d) {

            Some(l) => out.push(l),

                if let Some(ep) = endpoint {

                    if let Some(l) = learn_label(ep, &d).await {

                        out.push(l);

                    }

                }

    out

}

pub async fn unconnected(cwd: &Path, kind: &str) -> Result<i32> {

    let why = format!(

        cwd.display(),

        cwd.display()

    let mut out = tokio::io::stdout();

    let mut lines = BufReader::new(tokio::io::stdin()).lines();

    while let Some(line) = lines.next_line().await? {

        let Ok(req) = serde_json::from_str::<Json>(&line) else { continue };

        let Some(id) = req.get("id").cloned() else { continue };

        let result = match req.get("method").and_then(Json::as_str).unwrap_or("") {

            "initialize" => {

                let v = req.pointer("/params/protocolVersion").and_then(Json::as_str).unwrap_or(super::mcp::STDIO_VERSIONS[0]);

                let v = if super::mcp::STDIO_VERSIONS.contains(&v) { v } else { super::mcp::STDIO_VERSIONS[0] };

                json!({ "protocolVersion": v, "capabilities": { "tools": {} }, "serverInfo": { "name": "spectra", "version": env!("CARGO_PKG_VERSION") }, "instructions": why })

            "tools/list" => json!({ "tools": [] }),

            "ping" => json!({}),

                let e = json!({ "jsonrpc": "2.0", "id": id, "error": { "code": -32601, "message": why } });

                out.write_all(format!("{e}\n").as_bytes()).await?;

                out.flush().await?;

                continue;

        out.write_all(format!("{}\n", json!({ "jsonrpc": "2.0", "id": id, "result": result })).as_bytes()).await?;

        out.flush().await?;

    Ok(0)

}

pub async fn resolve(ctx: &super::Ctx, kind: &str) -> Result<Option<Label>> {

    let cwd = std::env::current_dir().context("this session's folder")?;

    let endpoint = ctx.endpoint().ok();

    let all = labels(endpoint.as_ref()).await;

    Ok(choose(&all, &cwd, kind).cloned())

}