eggsact 1.2.7

Deterministic MCP and in-process utility tools for coding agents
Documentation
use crate::mcp::machine_codes;
use crate::mcp::schemas::ToolResponse;
use crate::tools::helpers::*;
use serde_json::Value;

pub fn version_compare_tool(args: &Value) -> ToolResponse {
    let a = match args.get("a").and_then(|v| v.as_str()) {
        Some(s) => s,
        None => {
            return ToolResponse::error_with_code(
                "invalid_arguments",
                machine_codes::INVALID_ARGUMENTS,
                "Missing 'a' parameter",
                None,
                Some("version_compare"),
            )
        }
    };
    let b = match args.get("b").and_then(|v| v.as_str()) {
        Some(s) => s,
        None => {
            return ToolResponse::error_with_code(
                "invalid_arguments",
                machine_codes::INVALID_ARGUMENTS,
                "Missing 'b' parameter",
                None,
                Some("version_compare"),
            )
        }
    };
    let scheme = args
        .get("scheme")
        .and_then(|v| v.as_str())
        .unwrap_or("semver");

    if a.len() > MAX_TEXT_LENGTH || b.len() > MAX_TEXT_LENGTH {
        return ToolResponse::error_with_code(
            "input_too_large",
            machine_codes::INPUT_TOO_LARGE,
            &format!("Version string exceeds {} bytes", MAX_TEXT_LENGTH),
            None,
            Some("version_compare"),
        );
    }

    let valid_schemes = ["semver", "pep440", "loose"];
    if !valid_schemes.contains(&scheme) {
        return ToolResponse::error_with_code(
            "invalid_arguments",
            machine_codes::INVALID_ARGUMENTS,
            &format!("Unsupported scheme: {}", scheme),
            Some(vec![format!("Use one of: {}", valid_schemes.join(", "))]),
            Some("version_compare"),
        );
    }

    let result = crate::text::version::version_compare(a, b, scheme);
    ToolResponse::success(
        serde_json::json!({
            "comparison": result.comparison,
            "valid": result.valid,
            "scheme": result.scheme,
            "summary": result.summary,
        }),
        Some("version_compare"),
    )
    .with_tool("version_compare")
}

pub fn version_constraint_check(args: &Value) -> ToolResponse {
    let version = match args.get("version").and_then(|v| v.as_str()) {
        Some(s) => s,
        None => {
            return ToolResponse::error_with_code(
                "invalid_arguments",
                machine_codes::INVALID_ARGUMENTS,
                "Missing 'version' parameter",
                None,
                Some("version_constraint_check"),
            )
        }
    };
    let constraint = match args.get("constraint").and_then(|v| v.as_str()) {
        Some(s) => s,
        None => {
            return ToolResponse::error_with_code(
                "invalid_arguments",
                machine_codes::INVALID_ARGUMENTS,
                "Missing 'constraint' parameter",
                None,
                Some("version_constraint_check"),
            )
        }
    };
    let scheme = args
        .get("scheme")
        .and_then(|v| v.as_str())
        .unwrap_or("semver");

    let valid_schemes = ["semver", "cargo"];
    if !valid_schemes.contains(&scheme) {
        return ToolResponse::error_with_code(
            "invalid_arguments",
            machine_codes::INVALID_ARGUMENTS,
            &format!("Unsupported scheme: {}", scheme),
            Some(vec![format!("Use one of: {}", valid_schemes.join(", "))]),
            Some("version_constraint_check"),
        );
    }

    if version.trim().is_empty() {
        return ToolResponse::error_with_code(
            "invalid_arguments",
            machine_codes::INVALID_ARGUMENTS,
            "Version string is empty",
            Some(vec![
                "Provide a valid version string like '1.2.3'".to_string()
            ]),
            Some("version_constraint_check"),
        );
    }
    if constraint.trim().is_empty() {
        return ToolResponse::error_with_code(
            "invalid_arguments",
            machine_codes::INVALID_ARGUMENTS,
            "Constraint string is empty",
            Some(vec![
                "Provide a valid constraint like '>=1.0' or '^1.2.3'".to_string()
            ]),
            Some("version_constraint_check"),
        );
    }
    if version.len() > MAX_TEXT_LENGTH {
        return ToolResponse::error_with_code(
            "input_too_large",
            machine_codes::INPUT_TOO_LARGE,
            &format!("Input exceeds maximum length of {}", MAX_TEXT_LENGTH),
            None,
            Some("version_constraint_check"),
        );
    }
    if constraint.len() > MAX_TEXT_LENGTH {
        return ToolResponse::error_with_code(
            "input_too_large",
            machine_codes::INPUT_TOO_LARGE,
            &format!("Input exceeds maximum length of {}", MAX_TEXT_LENGTH),
            None,
            Some("version_constraint_check"),
        );
    }

    let result = crate::text::check_version_constraint(version, constraint, scheme);

    let satisfies = result.satisfies;
    let has_note = !result.findings.is_empty();

    let envelope_findings: Vec<serde_json::Value> = result
        .findings
        .iter()
        .map(|f| {
            serde_json::json!({
                "code": "CONSTRAINT_NOTE",
                "severity": "info",
                "message": f,
            })
        })
        .collect();

    let mut resp = ToolResponse::success(
        serde_json::json!({
            "satisfies": result.satisfies,
            "parsed_version": result.parsed_version,
            "parsed_constraint": result.parsed_constraint,
            "scheme": result.scheme,
            "explanation": result.explanation,
            "findings": result.findings,
        }),
        Some("version_constraint_check"),
    )
    .with_tool("version_constraint_check");

    if !envelope_findings.is_empty() {
        resp = resp.with_findings(envelope_findings);
    }
    if !satisfies {
        resp = resp.with_machine_code(machine_codes::CONSTRAINT_NOT_SATISFIED);
    } else if has_note {
        resp = resp.with_machine_code(machine_codes::CONSTRAINT_NOTE);
    }
    resp
}