agent-parameter-categorizer

λ(api, parameters) → categorization | ∀param ∈ parameters:

categorize :: (API, Parameters) → Categorization categorize(A, P) = read(A) → apply_tree(P) → group_by_tier() → order() → add_comments() → verify_determinism() → process_all() → report()

apply_decision_tree :: Parameter → Tier apply_decision_tree(p) = { tier: match p with | _ where p.required = true → 1, | _ where filters_results(p) → 2, | _ where defines_range(p) → 3, | _ where controls_output(p) → 4, | _ where is_standard(p) → 5, | _ → unclassified,

return {parameter: p.name, tier: tier, reason: explain_decision(p, tier)} }

filters_results :: Parameter → Bool filters_results(p) = (p.description ~ "filter|narrow|select|match") ∧ ¬(p.description ~ "limit|offset|count|size")

defines_range :: Parameter → Bool defines_range(p) = (p.name ~ "min_|max_|threshold|window|start_|end_") ∨ (p.description ~ "bound|range|minimum|maximum")

controls_output :: Parameter → Bool controls_output(p) = p.name ∈ {"limit", "offset", "output_format", "max_results"} ∨ (p.description ~ "output size|result count|format")

is_standard :: Parameter → Bool is_standard(p) = p.name ∈ {"scope", "jq_filter", "stats_only", "stats_first", "inline_threshold_bytes"}

categorize_all :: Parameters → Categorized_Parameters categorize_all(P) = { categorized: { tier_1: [p | p ∈ P ∧ apply_decision_tree(p).tier = 1], tier_2: [p | p ∈ P ∧ apply_decision_tree(p).tier = 2], tier_3: [p | p ∈ P ∧ apply_decision_tree(p).tier = 3], tier_4: [p | p ∈ P ∧ apply_decision_tree(p).tier = 4], tier_5: [p | p ∈ P ∧ apply_decision_tree(p).tier = 5], unclassified: [p | p ∈ P ∧ apply_decision_tree(p).tier = unclassified] },

return categorized }

order_by_tier :: Categorized_Parameters → Ordered_Parameters order_by_tier(C) = { ordered: flatten([ C.tier_1, C.tier_2, C.tier_3, C.tier_4, C.tier_5 ]),

return { parameters: ordered, sequence: [p.name | p ∈ ordered] } }

add_tier_comments :: Ordered_Parameters → Commented_Parameters add_tier_comments(O) = { with_comments: [],

∀tier ∈ [1, 2, 3, 4, 5] → params_in_tier: [p | p ∈ O.parameters ∧ p.tier = tier],

if |params_in_tier| > 0 then
  comment: generate_tier_comment(tier),
  with_comments += [comment] + params_in_tier,

return with_comments }

generate_tier_comment :: Tier → Comment generate_tier_comment(tier) = { comments: { 1: "// Tier 1: Required Parameters", 2: "// Tier 2: Filtering", 3: "// Tier 3: Range Parameters", 4: "// Tier 4: Output Control", 5: "// Tier 5: Standard Parameters (added automatically)" },

return comments[tier] }

verify_determinism :: Categorization → Determinism_Metrics verify_determinism(C) = { total: |C.all_parameters|, categorized: |C.tier_1| + |C.tier_2| + |C.tier_3| + |C.tier_4| + |C.tier_5|, ambiguous: |C.unclassified|, determinism_rate: categorized / total,

checks: { single_tier: ∀p ∈ C.all_parameters → count(t | p ∈ C[t]) = 1, consistent: ∀p ∈ C.all_parameters → apply_decision_tree(p).tier ≠ unclassified, ordered: sequence_matches_tier_order(C.ordered) },

return { total_parameters: total, categorized: categorized, ambiguous: ambiguous, determinism_rate: determinism_rate, all_checks_passed: checks.single_tier ∧ checks.consistent ∧ checks.ordered } }

process_all_tools :: Tools → Processing_Results process_all_tools(T) = { results: [],

∀tool ∈ T → parameters: extract_parameters(tool), categorization: categorize_all(parameters), ordering: order_by_tier(categorization), commented: add_tier_comments(ordering),

compliance_before: calculate_compliance(tool.current_order, ordering.sequence),

apply_reordering(tool, commented),

compliance_after: calculate_compliance(tool.new_order, ordering.sequence),

run_tests(tool),

results += {
  tool: tool.name,
  parameters_categorized: |parameters|,
  ambiguous_cases: |categorization.unclassified|,
  compliance_before: compliance_before,
  compliance_after: compliance_after,
  status: if compliance_after = 1.0 then "COMPLETED" else "NEEDS_REVIEW"
},