use std::collections::HashMap;
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ToolDescription {
pub summary: String,
pub usage_guide: String,
pub constraints: Vec<String>,
pub error_hints: HashMap<String, String>,
pub examples: Vec<ToolExample>,
pub security_notes: Vec<String>,
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct ToolExample {
pub title: String,
pub description: String,
pub input: serde_json::Value,
pub expected_output: String,
}
impl ToolDescription {
pub fn new(summary: impl Into<String>) -> Self {
Self {
summary: summary.into(),
usage_guide: String::new(),
constraints: Vec::new(),
error_hints: HashMap::new(),
examples: Vec::new(),
security_notes: Vec::new(),
}
}
pub fn with_usage_guide(mut self, guide: impl Into<String>) -> Self {
self.usage_guide = guide.into();
self
}
pub fn with_constraint(mut self, constraint: impl Into<String>) -> Self {
self.constraints.push(constraint.into());
self
}
pub fn with_error_hint(mut self, error_type: &str, hint: impl Into<String>) -> Self {
self.error_hints.insert(error_type.to_string(), hint.into());
self
}
pub fn with_example(mut self, example: ToolExample) -> Self {
self.examples.push(example);
self
}
pub fn with_security_note(mut self, note: impl Into<String>) -> Self {
self.security_notes.push(note.into());
self
}
pub fn build_prompt(&self) -> String {
let mut prompt = self.summary.clone();
if !self.usage_guide.is_empty() {
prompt.push_str(&format!("\n\n## Usage Guide\n{}", self.usage_guide));
}
if !self.constraints.is_empty() {
prompt.push_str("\n\n## Constraints");
for constraint in &self.constraints {
prompt.push_str(&format!("\n- {}", constraint));
}
}
if !self.security_notes.is_empty() {
prompt.push_str("\n\n## Security Notes");
for note in &self.security_notes {
prompt.push_str(&format!("\n- ⚠️ {}", note));
}
}
if !self.examples.is_empty() {
prompt.push_str("\n\n## Examples");
for (i, example) in self.examples.iter().enumerate() {
prompt.push_str(&format!(
"\n\n### Example {}: {}\n{}\n\n**Input:**\n```json\n{}\n```\n\n**Expected Output:**\n{}",
i + 1,
example.title,
example.description,
serde_json::to_string_pretty(&example.input).unwrap_or_else(|_| "{}".to_string()),
example.expected_output
));
}
}
if !self.error_hints.is_empty() {
prompt.push_str("\n\n## Troubleshooting");
for (error_type, hint) in &self.error_hints {
prompt.push_str(&format!("\n- **{}**: {}", error_type, hint));
}
}
prompt
}
pub fn build_compact_prompt(&self) -> String {
let mut prompt = self.summary.clone();
if !self.constraints.is_empty() {
prompt.push_str(" Constraints: ");
prompt.push_str(&self.constraints.join(", "));
}
if !self.security_notes.is_empty() {
prompt.push_str(" ⚠️ Security: ");
prompt.push_str(&self.security_notes.join("; "));
}
prompt
}
}
#[allow(dead_code)]
pub struct McpToolBuilder {
name: String,
description: ToolDescription,
input_schema: serde_json::Value,
output_schema: Option<serde_json::Value>,
}
impl McpToolBuilder {
pub fn new(name: impl Into<String>, description: ToolDescription) -> Self {
Self {
name: name.into(),
description,
input_schema: serde_json::json!({"type": "object", "properties": {}}),
output_schema: None,
}
}
pub fn with_input_schema(mut self, schema: serde_json::Value) -> Self {
self.input_schema = schema;
self
}
pub fn with_output_schema(mut self, schema: serde_json::Value) -> Self {
self.output_schema = Some(schema);
self
}
pub fn build(self) -> serde_json::Value {
let mut tool = serde_json::json!({
"name": self.name,
"description": self.description.build_prompt(),
"inputSchema": self.input_schema
});
if let Some(output_schema) = self.output_schema {
tool["outputSchema"] = output_schema;
}
tool
}
pub fn build_compact(self) -> serde_json::Value {
let mut tool = serde_json::json!({
"name": self.name,
"description": self.description.build_compact_prompt(),
"inputSchema": self.input_schema
});
if let Some(output_schema) = self.output_schema {
tool["outputSchema"] = output_schema;
}
tool
}
}
pub fn common_constraints() -> Vec<String> {
vec![
"Ensure Terraform is initialized before running operations".to_string(),
"Validate directory permissions before executing commands".to_string(),
"Check security policy settings for dangerous operations".to_string(),
"Use proper namespace format (e.g., 'hashicorp/aws' or auto-fallback)".to_string(),
"Provider search queries should be specific but not overly narrow".to_string(),
]
}
pub fn common_error_hints() -> HashMap<String, String> {
let mut hints = HashMap::new();
hints.insert(
"Init Required".to_string(),
"Run 'terraform init' first to initialize the working directory".to_string(),
);
hints.insert(
"Permission Denied".to_string(),
"Check if TFMCP_ALLOW_DANGEROUS_OPS environment variable is set for apply/destroy operations".to_string(),
);
hints.insert(
"Provider Not Found".to_string(),
"Verify provider name and namespace, or try without specifying namespace for auto-fallback"
.to_string(),
);
hints.insert(
"Invalid Configuration".to_string(),
"Run validation tools to check Terraform configuration syntax and semantics".to_string(),
);
hints
}
pub fn common_security_notes() -> Vec<String> {
vec![
"Apply and destroy operations are disabled by default for safety".to_string(),
"Set TFMCP_ALLOW_DANGEROUS_OPS=true to enable infrastructure modifications".to_string(),
"All operations are logged to ~/.tfmcp/audit.log for security monitoring".to_string(),
"Production directory patterns are automatically blocked".to_string(),
]
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tool_description_builder() {
let desc = ToolDescription::new("Test tool for demonstrations")
.with_usage_guide("Use this tool when you need to test something")
.with_constraint("Only use in development environments")
.with_error_hint("TestError", "This is how you fix test errors")
.with_security_note("Test operations are safe");
let prompt = desc.build_prompt();
assert!(prompt.contains("Test tool for demonstrations"));
assert!(prompt.contains("Usage Guide"));
assert!(prompt.contains("Constraints"));
assert!(prompt.contains("Security Notes"));
assert!(prompt.contains("Troubleshooting"));
}
#[test]
fn test_tool_description_compact() {
let desc = ToolDescription::new("Test tool")
.with_constraint("Dev only")
.with_security_note("Safe operation");
let compact = desc.build_compact_prompt();
assert!(compact.contains("Test tool"));
assert!(compact.contains("Constraints: Dev only"));
assert!(compact.contains("⚠️ Security: Safe operation"));
}
#[test]
fn test_mcp_tool_builder() {
let desc = ToolDescription::new("Test MCP tool");
let builder = McpToolBuilder::new("test_tool", desc);
let tool = builder.build();
assert_eq!(tool["name"], "test_tool");
assert!(
tool["description"]
.as_str()
.unwrap()
.contains("Test MCP tool")
);
assert!(tool["inputSchema"].is_object());
}
#[test]
fn test_common_helpers() {
let constraints = common_constraints();
assert!(!constraints.is_empty());
let hints = common_error_hints();
assert!(hints.contains_key("Init Required"));
let security_notes = common_security_notes();
assert!(!security_notes.is_empty());
}
}