agent-validation-builder

λ(target, conventions) → validation_tool | ∀validator ∈ validators:

build :: (Target, Conventions) → Validation_Tool build(T, C) = design_types() → implement_parser(T.format) → create_validators(C) → build_reporter() → integrate_cli() → add_tests() → document() → integrate_workflow() → continuous_improvement()

design_types :: () → Type_System design_types() = { Tool: {name: string, description: string, parameters: [Parameter]}, Parameter: {name: string, type: string, description: string, required: bool}, ValidationResult: {tool_name: string, check_name: string, passed: bool, message: string, severity: string, details: map}, Report: {total_tools: int, total_checks: int, passed: int, failed: int, warnings: int, results: [ValidationResult]},

return {Tool, Parameter, ValidationResult, Report} }

implement_parser :: Format → Parser implement_parser(format) = { parser: match format with | "json_schema" → regex_parser(), # MVP: Fast, simple | "openapi" → ast_parser(), # Production: Robust | "graphql" → ast_parser(), | _ → custom_parser(),

regex_parser: { tool_pattern: "Name:\s*"([^"]+)"", desc_pattern: "Description:\s*"([^"]+)"", param_pattern: ""([^"]+)":\s*{[^}]Type:\s"([^"]+)"", extract: λcontent → match_all(patterns, content) },

ast_parser: { parse: "go/parser.ParseFile(file)", traverse: "ast.Inspect(node, visitor)", extract: λnode → extract_tool_definitions(node) },

return parser }

create_validators :: Conventions → Validators create_validators(C) = { validators: [],

∀convention ∈ C → validator: match convention with | "naming_convention" → create_naming_validator(), | "parameter_ordering" → create_ordering_validator(), | "description_format" → create_description_validator(), | _ → create_custom_validator(convention),

validators += validator,

return validators }

create_naming_validator :: () → Validator create_naming_validator() = { pattern: "^[a-z][a-z0-9_]*$", # snake_case

check: λtool → { if ¬matches(tool.name, pattern) then { tool_name: tool.name, check_name: "naming_convention", passed: false, message: "Tool name '" + tool.name + "' violates naming convention", severity: "ERROR", details: { suggestion: "Use snake_case format", expected: "snake_case_pattern", actual: tool.name, reference: "docs/api-naming-convention.md" } } else {tool_name: tool.name, check_name: "naming_convention", passed: true, severity: "INFO"} } }

create_ordering_validator :: () → Validator create_ordering_validator() = { tier_system: TierDefinitions,

check: λtool → { categorized: categorize_parameters(tool.parameters, tier_system), expected_order: sort_by_tier(categorized), actual_order: tool.parameters,

matches: ∀i ∈ [0..|expected_order|] → expected_order[i].name = actual_order[i].name,

if ¬matches then
  {
    tool_name: tool.name,
    check_name: "parameter_ordering",
    passed: false,
    message: "Parameters not in tier order",
    severity: "ERROR",
    details: {
      suggestion: "Reorder parameters by tier (1→2→3→4→5)",
      expected: [p.name | p ∈ expected_order],
      actual: [p.name | p ∈ actual_order],
      reference: "docs/api-parameter-convention.md"
    }
  }
else
  {tool_name: tool.name, check_name: "parameter_ordering", passed: true, severity: "INFO"}

} }

create_description_validator :: () → Validator create_description_validator() = { required_pattern: "Default scope:",

check: λtool → { if ¬contains(tool.description, required_pattern) then { tool_name: tool.name, check_name: "description_format", passed: false, message: "Missing required pattern: '" + required_pattern + "'", severity: "WARNING", details: { suggestion: "Add '" + required_pattern + " ' to description", expected: "Description with scope declaration", actual: tool.description, reference: "docs/api-consistency-methodology.md" } } else {tool_name: tool.name, check_name: "description_format", passed: true, severity: "INFO"} } }