libmcp 1.1.0

Industrial MCP hardening spine with host/worker recovery, model-facing rendering doctrine, and operational telemetry.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Shared normalization helpers for model-facing input.

use std::path::{Path, PathBuf};
use thiserror::Error;
use url::Url;

/// A numeric input could not be normalized.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
pub enum NumericParseError {
    /// The input was empty.
    #[error("numeric input must be non-empty")]
    Empty,
    /// The input could not be represented as a non-negative integer.
    #[error("expected a non-negative integer")]
    Invalid,
}

/// A path-like value could not be normalized.
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum PathNormalizeError {
    /// The input was empty.
    #[error("path input must be non-empty")]
    Empty,
    /// The `file://` URI was malformed.
    #[error("file URI is invalid")]
    InvalidFileUri,
    /// The URI does not reference a local path.
    #[error("file URI must resolve to a local path")]
    NonLocalFileUri,
}

/// Parses a human-facing unsigned integer.
///
/// This accepts:
///
/// - integer numbers
/// - integer-like floating-point spellings such as `42.0`
/// - numeric strings
#[must_use]
pub fn parse_human_unsigned_u64(raw: &str) -> Option<u64> {
    let trimmed = raw.trim();
    if trimmed.is_empty() {
        return None;
    }
    if let Ok(value) = trimmed.parse::<u64>() {
        return Some(value);
    }
    let parsed_float = trimmed.parse::<f64>().ok()?;
    if !parsed_float.is_finite() || parsed_float < 0.0 || parsed_float.fract() != 0.0 {
        return None;
    }
    let max = u64::MAX as f64;
    if parsed_float > max {
        return None;
    }
    Some(parsed_float as u64)
}

/// Converts `u64` to `usize`, saturating on overflow.
#[must_use]
pub fn saturating_u64_to_usize(value: u64) -> usize {
    usize::try_from(value).unwrap_or(usize::MAX)
}

/// Normalizes a token by dropping non-alphanumeric ASCII and lowercasing.
#[must_use]
pub fn normalize_ascii_token(raw: &str) -> String {
    raw.chars()
        .filter(|character| character.is_ascii_alphanumeric())
        .map(|character| character.to_ascii_lowercase())
        .collect()
}

/// Resolves a local path or `file://` URI to an absolute path.
pub fn normalize_local_path(
    raw: &str,
    workspace_root: Option<&Path>,
) -> Result<PathBuf, PathNormalizeError> {
    let trimmed = raw.trim();
    if trimmed.is_empty() {
        return Err(PathNormalizeError::Empty);
    }
    let parsed = if trimmed.starts_with("file://") {
        let file_url = Url::parse(trimmed).map_err(|_| PathNormalizeError::InvalidFileUri)?;
        file_url
            .to_file_path()
            .map_err(|()| PathNormalizeError::NonLocalFileUri)?
    } else {
        PathBuf::from(trimmed)
    };
    Ok(if parsed.is_absolute() {
        parsed
    } else if let Some(workspace_root) = workspace_root {
        workspace_root.join(parsed)
    } else {
        parsed
    })
}

#[cfg(test)]
mod tests {
    use super::{normalize_ascii_token, normalize_local_path, parse_human_unsigned_u64};
    use std::path::Path;

    #[test]
    fn parses_human_unsigned_integers() {
        assert_eq!(parse_human_unsigned_u64("42"), Some(42));
        assert_eq!(parse_human_unsigned_u64("42.0"), Some(42));
        assert_eq!(parse_human_unsigned_u64(" 7 "), Some(7));
        assert_eq!(parse_human_unsigned_u64("-1"), None);
        assert_eq!(parse_human_unsigned_u64("7.5"), None);
    }

    #[test]
    fn normalizes_ascii_tokens() {
        assert_eq!(
            normalize_ascii_token("textDocument/prepareRename"),
            "textdocumentpreparerename"
        );
        assert_eq!(normalize_ascii_token("prepare_rename"), "preparerename");
    }

    #[test]
    fn resolves_relative_paths_against_workspace_root() {
        let root = Path::new("/tmp/example-root");
        let resolved = normalize_local_path("src/lib.rs", Some(root));
        assert!(resolved.is_ok());
        assert_eq!(
            resolved.ok().as_deref(),
            Some(root.join("src/lib.rs").as_path())
        );
    }
}