use std::env;
use eggsact::mcp::runtime;
mod integrate;
mod update;
#[derive(Debug, PartialEq, Eq)]
enum CliCommand {
Help,
Version,
Mcp {
surface: eggsact::mcp::discovery::McpSurface,
},
Diagnostics {
format: String,
},
Update,
Integrate {
client: Option<String>,
discovery: bool,
},
Error(String),
Evaluate(String),
}
fn parse_args(args: impl IntoIterator<Item = String>) -> CliCommand {
let args: Vec<String> = args.into_iter().collect();
if args.iter().any(|a| a == "--mcp") {
let mut surface = eggsact::mcp::discovery::McpSurface::Direct;
let mut surface_seen = false;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--mcp" => {}
"--mcp-surface" => {
if surface_seen || i + 1 >= args.len() {
return CliCommand::Error(
"--mcp-surface requires exactly one value: direct or discovery"
.to_string(),
);
}
surface_seen = true;
let raw = args[i + 1].as_str();
match eggsact::mcp::discovery::McpSurface::parse(raw) {
Some(s) => surface = s,
None => {
return CliCommand::Error(format!(
"unknown MCP surface '{}'; expected direct or discovery",
raw
));
}
}
i += 1;
}
other => {
return CliCommand::Error(format!(
"unexpected argument '{}' with --mcp",
other
));
}
}
i += 1;
}
return CliCommand::Mcp { surface };
}
if args.iter().any(|a| a == "--mcp-surface") {
return CliCommand::Error("--mcp-surface requires --mcp".to_string());
}
match args.as_slice() {
[] => CliCommand::Help,
[flag] if flag == "-h" || flag == "--help" => CliCommand::Help,
[flag] if flag == "-V" || flag == "--version" => CliCommand::Version,
[command] if command == "update" => CliCommand::Update,
[command, client, flag] if command == "integrate" && flag == "--discovery" => {
CliCommand::Integrate {
client: Some(client.clone()),
discovery: true,
}
}
[command, client] if command == "integrate" => CliCommand::Integrate {
client: Some(client.clone()),
discovery: false,
},
[command] if command == "integrate" => CliCommand::Integrate {
client: None,
discovery: false,
},
_ => {
if !args.iter().any(|arg| arg == "--diagnostics") {
if args.iter().any(|arg| arg == "--format") {
return CliCommand::Error(
"--format is only valid with --diagnostics".to_string(),
);
}
return CliCommand::Evaluate(args.join(" "));
}
let mut format = "text";
let mut format_seen = false;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--diagnostics" => {}
"--format" => {
if format_seen || i + 1 >= args.len() {
return CliCommand::Error(
"--format requires exactly one value: json or text".to_string(),
);
}
format_seen = true;
format = args[i + 1].as_str();
i += 1;
if format != "json" && format != "text" {
return CliCommand::Error(format!(
"unknown diagnostics format '{}'; expected json or text",
format
));
}
}
other => {
return CliCommand::Error(format!(
"unexpected argument '{}' with --diagnostics",
other
));
}
}
i += 1;
}
CliCommand::Diagnostics {
format: format.to_string(),
}
}
}
}
fn print_usage() {
println!("Usage: eggsact [--mcp [--mcp-surface direct|discovery] | --diagnostics [--format json|text] | update | integrate <client> [--discovery] | expression]");
println!(" --mcp Start MCP server mode");
println!(" --mcp-surface Presentation surface: direct (default) or discovery (pinned front doors + tool_search/tool_invoke)");
println!(" --diagnostics Print diagnostic information");
println!(" --format json|text Output format for --diagnostics (default: text)");
println!(" -h, --help Print this help message");
println!(" -V, --version Print version information");
println!(" update Update from the latest stable crates.io release");
println!(" integrate <name> Render MCP setup for a client (or list/detect) [--discovery renders --mcp-surface discovery args]");
println!(" expression Evaluate math expression");
}
fn print_diagnostics(format: &str) {
let version = env!("CARGO_PKG_VERSION");
let tool_count = eggsact::mcp::registry::tool_count();
let profiles = eggsact::mcp::registry::available_profiles();
let compat_mcp = "EggcalcPython";
let compat_inprocess = "StrictNative";
let env_var_names = [
"EGGCALC_NO_CONFIG",
"EGGCALC_MCP_PROFILE",
"EGGCALC_MCP_AUDIENCE",
"EGGCALC_MCP_SCHEMA_DETAIL",
"EGGSACT_MCP_SURFACE",
];
let route_critical = eggsact::mcp::registry::ROUTE_CRITICAL_TOOLS;
let direct_discovery_metrics = (
eggsact::mcp::discovery_eval::direct_metrics(
"full",
eggsact::mcp::registry::ToolListAudience::Model,
),
eggsact::mcp::discovery_eval::discovery_metrics(
"full",
eggsact::mcp::registry::ToolListAudience::Model,
),
);
let budget_tiers = [
("cheap", "1 MB in/out, 10s, 100 findings"),
("moderate", "1 MB in/out, 30s, 100 findings"),
("heavy", "1 MB in / 2 MB out, 30s, 100 findings"),
];
if format == "json" {
let profiles_obj: serde_json::Map<String, serde_json::Value> = profiles
.iter()
.map(|p| {
let count = eggsact::mcp::registry::tools_for_profile(p).len();
(p.to_string(), serde_json::Value::Number(count.into()))
})
.collect();
let tiers_obj: serde_json::Map<String, serde_json::Value> = budget_tiers
.iter()
.map(|(name, desc)| {
(
name.to_string(),
serde_json::Value::String(desc.to_string()),
)
})
.collect();
let env_vars: Vec<serde_json::Value> = env_var_names
.iter()
.map(|v| serde_json::Value::String(v.to_string()))
.collect();
let route_critical_vec: Vec<serde_json::Value> = route_critical
.iter()
.map(|name| serde_json::Value::String(name.to_string()))
.collect();
let diag = serde_json::json!({
"version": version,
"tool_count": tool_count,
"profiles": profiles_obj,
"compatibility_mode": {
"mcp_server": compat_mcp,
"in_process_api": compat_inprocess,
},
"route_critical_tools": route_critical_vec,
"budget_tiers": tiers_obj,
"discovery_metrics": {
"direct_full_model": direct_discovery_metrics.0,
"discovery_full_model": direct_discovery_metrics.1,
"discovery_ratio": eggsact::mcp::discovery_eval::discovery_ratio(
"full",
eggsact::mcp::registry::ToolListAudience::Model,
),
},
"runtime": {
"active_profile": runtime::get_active_profile(),
"active_audience": runtime::get_active_audience().to_string(),
"schema_detail": runtime::get_schema_detail(),
"active_surface": runtime::get_active_surface().to_string(),
"limits": {
"max_in_flight_requests": runtime::MAX_IN_FLIGHT_REQUESTS,
"max_tool_workers": runtime::MAX_TOOL_WORKERS,
"max_request_bytes": runtime::MAX_REQUEST_BYTES,
"max_output_bytes": runtime::MAX_OUTPUT_BYTES,
},
},
"env_var_names": env_vars,
});
println!("{}", serde_json::to_string_pretty(&diag).unwrap());
} else {
println!("eggsact diagnostics (v{})", version);
println!();
println!("Tools: {} total", tool_count);
println!();
println!("Profiles:");
for p in profiles {
let count = eggsact::mcp::registry::tools_for_profile(p).len();
println!(" {}: {} tools", p, count);
}
println!();
println!("Route-critical tools:");
for name in route_critical {
println!(" {}", name);
}
println!();
println!("Compatibility mode (default by surface):");
println!(" MCP server: {}", compat_mcp);
println!(" In-process API: {}", compat_inprocess);
println!();
println!("Runtime:");
println!(" Active profile: {}", runtime::get_active_profile());
println!(" Active audience: {}", runtime::get_active_audience());
println!(" Schema detail: {}", runtime::get_schema_detail());
println!(" Active surface: {}", runtime::get_active_surface());
println!(
" Discovery context: {} direct bytes, {} discovery bytes ({:.1}%)",
direct_discovery_metrics.0.serialized_bytes,
direct_discovery_metrics.1.serialized_bytes,
eggsact::mcp::discovery_eval::discovery_ratio(
"full",
eggsact::mcp::registry::ToolListAudience::Model,
) * 100.0
);
println!(
" Limits: {} in-flight, {} workers, {} bytes request, {} bytes output",
runtime::MAX_IN_FLIGHT_REQUESTS,
runtime::MAX_TOOL_WORKERS,
runtime::MAX_REQUEST_BYTES,
runtime::MAX_OUTPUT_BYTES,
);
println!();
println!("Budget tiers:");
for (name, desc) in &budget_tiers {
println!(" {}: {}", name, desc);
}
println!();
println!("Known env vars (names only, no values):");
for v in &env_var_names {
println!(" {}", v);
}
}
}
fn main() {
match parse_args(env::args().skip(1)) {
CliCommand::Help => print_usage(),
CliCommand::Version => println!("eggsact {}", env!("CARGO_PKG_VERSION")),
CliCommand::Mcp { surface } => {
if let Err(error) = runtime::init_active_profile() {
eprintln!("Error: {error}");
std::process::exit(1);
}
if let Err(error) = runtime::init_active_surface() {
eprintln!("Error: {error}");
std::process::exit(1);
}
if surface != eggsact::mcp::discovery::McpSurface::Direct
|| std::env::var("EGGSACT_MCP_SURFACE").is_ok()
{
let explicit = env::args().any(|a| a == "--mcp-surface");
if explicit {
if let Err(error) = runtime::set_active_surface(surface) {
eprintln!("Error: {error}");
std::process::exit(1);
}
}
}
#[cfg(not(debug_assertions))]
eggsact::calc::normalize::warm_calculator_regex_cache();
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.thread_name("eggsact-mcp")
.build()
.expect("failed to create Tokio runtime");
rt.block_on(eggsact::mcp::server::main());
}
CliCommand::Diagnostics { format } => print_diagnostics(&format),
CliCommand::Update => {
if let Err(error) = update::run() {
eprintln!("Error: {error}");
std::process::exit(1);
}
}
CliCommand::Integrate { client, discovery } => {
if let Err(error) = integrate::run_with_options(client.as_deref(), discovery) {
eprintln!("Error: {error}");
std::process::exit(2);
}
}
CliCommand::Error(error) => {
eprintln!("Error: {error}");
print_usage();
std::process::exit(2);
}
CliCommand::Evaluate(expression) => match eggsact::calc::run(&expression) {
Ok((result, _type)) => println!("{}", result),
Err(e) => {
eprintln!("Error: {}", e);
std::process::exit(1);
}
},
}
}
#[cfg(test)]
mod tests {
use super::{parse_args, CliCommand};
fn args(items: &[&str]) -> Vec<String> {
items.iter().map(|s| s.to_string()).collect()
}
#[test]
fn parse_no_args_as_help() {
assert_eq!(parse_args(args(&[])), CliCommand::Help);
}
#[test]
fn parse_help_flags() {
assert_eq!(parse_args(args(&["--help"])), CliCommand::Help);
assert_eq!(parse_args(args(&["-h"])), CliCommand::Help);
}
#[test]
fn parse_version_flags() {
assert_eq!(parse_args(args(&["--version"])), CliCommand::Version);
assert_eq!(parse_args(args(&["-V"])), CliCommand::Version);
}
#[test]
fn parse_mcp_flag() {
use eggsact::mcp::discovery::McpSurface;
assert_eq!(
parse_args(args(&["--mcp"])),
CliCommand::Mcp {
surface: McpSurface::Direct
}
);
assert_eq!(
parse_args(args(&["--mcp", "--mcp-surface", "discovery"])),
CliCommand::Mcp {
surface: McpSurface::Discovery
}
);
assert_eq!(
parse_args(args(&["--mcp", "--mcp-surface", "direct"])),
CliCommand::Mcp {
surface: McpSurface::Direct
}
);
assert!(matches!(
parse_args(args(&["--mcp", "--mcp-surface", "bogus"])),
CliCommand::Error(_)
));
assert!(matches!(
parse_args(args(&["--mcp-surface", "discovery"])),
CliCommand::Error(_)
));
}
#[test]
fn parse_reserved_commands() {
assert_eq!(parse_args(args(&["update"])), CliCommand::Update);
assert_eq!(
parse_args(args(&["integrate"])),
CliCommand::Integrate {
client: None,
discovery: false
}
);
assert_eq!(
parse_args(args(&["integrate", "zed"])),
CliCommand::Integrate {
client: Some("zed".to_string()),
discovery: false
}
);
assert_eq!(
parse_args(args(&["integrate", "zed", "--discovery"])),
CliCommand::Integrate {
client: Some("zed".to_string()),
discovery: true
}
);
}
#[test]
fn parse_expression_joins_all_remaining_args() {
assert_eq!(
parse_args(args(&["thirty", "plus", "five"])),
CliCommand::Evaluate("thirty plus five".to_string())
);
}
#[test]
fn parse_diagnostics_flag() {
assert_eq!(
parse_args(args(&["--diagnostics"])),
CliCommand::Diagnostics {
format: "text".to_string()
}
);
}
#[test]
fn parse_diagnostics_format_json() {
assert_eq!(
parse_args(args(&["--diagnostics", "--format", "json"])),
CliCommand::Diagnostics {
format: "json".to_string()
}
);
}
#[test]
fn parse_diagnostics_format_is_order_independent() {
assert_eq!(
parse_args(args(&["--format", "json", "--diagnostics"])),
CliCommand::Diagnostics {
format: "json".to_string()
}
);
}
#[test]
fn parse_diagnostics_rejects_unknown_format() {
assert!(matches!(
parse_args(args(&["--diagnostics", "--format", "xml"])),
CliCommand::Error(_)
));
}
#[test]
fn parse_format_without_diagnostics_is_an_error() {
assert!(matches!(
parse_args(args(&["--format", "json"])),
CliCommand::Error(_)
));
}
}