cargo-mcp 0.2.0

mcp server for cargo commands
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

use crate::state::CargoTools;
use crate::tools::cargo_utils::{create_cargo_command, execute_cargo_command};
use anyhow::Result;
use mcplease::{
    traits::{Tool, WithExamples},
    types::Example,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Update dependencies using cargo update
#[derive(Debug, Serialize, Deserialize, schemars::JsonSchema, clap::Args)]
#[serde(rename = "cargo_update")]
pub struct CargoUpdate {
    /// Optional package name (for workspaces)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[arg(long)]
    pub package: Option<String>,

    /// Optional specific dependencies to update
    #[serde(skip_serializing_if = "Option::is_none")]
    #[arg(long)]
    pub dependencies: Option<Vec<String>>,

    /// Perform a dry run to see what would be updated
    #[serde(skip_serializing_if = "Option::is_none")]
    #[arg(long)]
    pub dry_run: Option<bool>,

    /// Optional Rust toolchain to use (e.g., 'stable', 'nightly', '1.70.0')
    #[serde(skip_serializing_if = "Option::is_none")]
    #[arg(long)]
    pub toolchain: Option<String>,

    /// Optional environment variables to set for the cargo command
    #[serde(skip_serializing_if = "Option::is_none")]
    #[arg(skip)]
    pub cargo_env: Option<HashMap<String, String>>,
}

impl WithExamples for CargoUpdate {
    fn examples() -> Vec<Example<Self>> {
        vec![
            Example {
                description: "Update all dependencies",
                item: Self {
                    package: None,
                    dependencies: None,
                    dry_run: None,
                    toolchain: None,
                    cargo_env: None,
                },
            },
            Example {
                description: "Dry run to see what would be updated",
                item: Self {
                    package: None,
                    dependencies: None,
                    dry_run: Some(true),
                    toolchain: None,
                    cargo_env: None,
                },
            },
            Example {
                description: "Update specific dependencies",
                item: Self {
                    package: None,
                    dependencies: Some(vec!["serde".into(), "tokio".into()]),
                    dry_run: None,
                    toolchain: None,
                    cargo_env: None,
                },
            },
            Example {
                description: "Update dependencies for a specific package",
                item: Self {
                    package: Some("my-lib".into()),
                    dependencies: None,
                    dry_run: None,
                    toolchain: None,
                    cargo_env: None,
                },
            },
        ]
    }
}

impl Tool<CargoTools> for CargoUpdate {
    fn execute(self, state: &mut CargoTools) -> Result<String> {
        let project_path = state.ensure_rust_project(None)?;
        
        // Use toolchain from args, session default, or none
        let toolchain = self.toolchain
            .or_else(|| state.get_default_toolchain(None).unwrap_or(None));


        let mut args = vec!["update"];
        
        if let Some(ref package) = self.package {
            args.extend_from_slice(&["--package", package]);
        }

        if self.dry_run.unwrap_or(false) {
            args.push("--dry-run");
        }

        // Add specific dependencies to update if provided
        if let Some(ref deps) = self.dependencies {
            for dep in deps {
                args.extend_from_slice(&["--package", dep]);
            }
        }

        let cmd = create_cargo_command(&args, toolchain.as_deref(), self.cargo_env.as_ref());
        execute_cargo_command(cmd, &project_path, "cargo update")
    }
}