impl TdgSystemDiagnosticsTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgSystemDiagnosticsTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgSystemDiagnosticsTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_system_diagnostics with args: {}", args);
let params: TdgSystemDiagnosticsArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let result = tdg_system_diagnostics(params.detailed, params.components)
.await
.map_err(|e| Error::internal(format!("TDG diagnostics failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let schema = json!({
"type": "object",
"properties": {
"detailed": { "type": "boolean", "description": "Include detailed per-component diagnostics" },
"components": {
"type": "array", "items": { "type": "string" },
"description": "Subset of components to inspect (empty = all)"
}
}
});
Some(build_tool_info(
"tdg_system_diagnostics",
"Run comprehensive diagnostics on the TDG (Technical Debt Grading) system.",
schema,
))
}
}
impl TdgStorageManagementTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgStorageManagementTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgStorageManagementTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_storage_management with args: {}", args);
let params: TdgStorageManagementArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let result = tdg_storage_management(params.action, params.options)
.await
.map_err(|e| Error::internal(format!("TDG storage management failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let schema = json!({
"type": "object",
"properties": {
"action": { "type": "string", "description": "Storage action (compact, purge, stats, vacuum, etc.)" },
"options": { "type": "object", "description": "Freeform options object for the given action" }
},
"required": ["action"]
});
Some(build_tool_info(
"tdg_storage_management",
"Perform a storage management action (compact, purge, vacuum, etc.) on the TDG backend.",
schema,
))
}
}
impl TdgAnalyzeWithStorageTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgAnalyzeWithStorageTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgAnalyzeWithStorageTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_analyze_with_storage with args: {}", args);
let params: TdgAnalyzeWithStorageArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let paths: Vec<PathBuf> = params.paths.into_iter().map(PathBuf::from).collect();
if paths.is_empty() {
return Err(Error::validation(
"At least one path must be specified".to_string(),
));
}
let result = tdg_analyze_with_storage(paths, params.storage_backend, params.priority)
.await
.map_err(|e| Error::internal(format!("TDG analysis failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let extra = json!({
"storage_backend": { "type": "string", "description": "Storage backend name (e.g. sqlite, in-memory)" },
"priority": { "type": "string", "description": "Analysis priority (low, normal, high)" }
});
Some(build_tool_info(
"tdg_analyze_with_storage",
"Analyze the given paths through the transactional TDG storage backend.",
paths_object_schema(extra, vec!["paths"]),
))
}
}
impl TdgPerformanceMetricsTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgPerformanceMetricsTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgPerformanceMetricsTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_performance_metrics with args: {}", args);
let _params: TdgPerformanceMetricsArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let result = tdg_performance_metrics()
.await
.map_err(|e| Error::internal(format!("TDG performance metrics failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let schema = json!({
"type": "object",
"properties": {
"include_history": { "type": "boolean", "description": "Include historical trend data" },
"metrics": {
"type": "array", "items": { "type": "string" },
"description": "Subset of metric names to return (empty = all)"
}
}
});
Some(build_tool_info(
"tdg_performance_metrics",
"Return real-time TDG system performance metrics.",
schema,
))
}
}
impl TdgConfigureStorageTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgConfigureStorageTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgConfigureStorageTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_configure_storage with args: {}", args);
let params: TdgConfigureStorageArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let result = tdg_configure_storage(
params.backend_type,
params.path,
params.cache_size_mb,
params.compression,
)
.await
.map_err(|e| Error::internal(format!("TDG storage configuration failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let schema = json!({
"type": "object",
"properties": {
"backend_type": { "type": "string", "description": "Backend type identifier (sqlite, rocks, memory, etc.)" },
"path": { "type": "string", "description": "Storage path" },
"cache_size_mb": { "type": "integer", "description": "In-memory cache size in MB" },
"compression": { "type": "boolean", "description": "Enable on-disk compression" }
},
"required": ["backend_type"]
});
Some(build_tool_info(
"tdg_configure_storage",
"Configure and validate the TDG storage backend.",
schema,
))
}
}
impl TdgHealthCheckTool {
#[must_use]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn new() -> Self {
Self
}
}
impl Default for TdgHealthCheckTool {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl ToolHandler for TdgHealthCheckTool {
async fn handle(&self, args: Value, _extra: RequestHandlerExtra) -> Result<Value> {
debug!("Handling tdg_health_check with args: {}", args);
let _params: TdgHealthCheckArgs = serde_json::from_value(args)
.map_err(|e| Error::validation(format!("Invalid arguments: {e}")))?;
let result = tdg_health_check()
.await
.map_err(|e| Error::internal(format!("TDG health check failed: {e}")))?;
Ok(result)
}
fn metadata(&self) -> Option<ToolInfo> {
let schema = json!({
"type": "object",
"properties": {
"include_recommendations": { "type": "boolean", "description": "Include remediation recommendations" },
"check_storage": { "type": "boolean", "description": "Run storage-backend health probe" },
"check_performance": { "type": "boolean", "description": "Run performance-budget health probe" }
}
});
Some(build_tool_info(
"tdg_health_check",
"Run a comprehensive TDG-system health check (storage, performance, recommendations).",
schema,
))
}
}