agentic-qe 3.4.1 → 3.4.2

package/.claude/skills/test-data-management/schemas/output.json

@@ -0,0 +1,284 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://agentic-qe.dev/schemas/test-data-management-output.json",
+  "title": "AQE Test Data Management Skill Output Schema",
+  "description": "Schema for test data generation, management, and privacy compliance output.",
+  "type": "object",
+  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
+  "properties": {
+    "skillName": {
+      "type": "string",
+      "const": "test-data-management",
+      "description": "Skill identifier"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
+    },
+    "timestamp": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["success", "partial", "failed", "skipped"]
+    },
+    "trustTier": {
+      "type": "integer",
+      "const": 3
+    },
+    "output": {
+      "type": "object",
+      "required": ["summary", "dataGeneration", "privacyCompliance", "metrics"],
+      "properties": {
+        "summary": {
+          "type": "string",
+          "minLength": 10,
+          "maxLength": 2000
+        },
+        "score": {
+          "$ref": "#/$defs/dataManagementScore"
+        },
+        "dataGeneration": {
+          "$ref": "#/$defs/dataGeneration",
+          "description": "Data generation results"
+        },
+        "privacyCompliance": {
+          "$ref": "#/$defs/privacyCompliance",
+          "description": "Privacy/GDPR compliance status"
+        },
+        "dataQuality": {
+          "$ref": "#/$defs/dataQuality",
+          "description": "Data quality assessment"
+        },
+        "schemas": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/schemaResult"
+          },
+          "description": "Schema validation results"
+        },
+        "findings": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/dataFinding"
+          },
+          "maxItems": 500
+        },
+        "recommendations": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/recommendation"
+          },
+          "maxItems": 100
+        },
+        "metrics": {
+          "$ref": "#/$defs/dataMetrics"
+        },
+        "artifacts": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/artifact"
+          },
+          "maxItems": 50
+        }
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "executionTimeMs": { "type": "integer", "minimum": 0 },
+        "toolsUsed": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": ["faker", "factory-bot", "test-containers", "anonymizer", "synthetic-data-vault"]
+          }
+        },
+        "agentId": { "type": "string", "pattern": "^qe-[a-z][a-z0-9-]*$" },
+        "targetDatabase": { "type": "string" }
+      }
+    },
+    "validation": {
+      "type": "object",
+      "properties": {
+        "schemaValid": { "type": "boolean" },
+        "contentValid": { "type": "boolean" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "learning": {
+      "type": "object",
+      "properties": {
+        "patternsDetected": { "type": "array", "items": { "type": "string" } },
+        "reward": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  },
+  "$defs": {
+    "dataManagementScore": {
+      "type": "object",
+      "required": ["value", "max"],
+      "properties": {
+        "value": { "type": "number", "minimum": 0, "maximum": 100 },
+        "max": { "type": "number", "const": 100 },
+        "grade": { "type": "string", "pattern": "^[A-F][+-]?$" },
+        "privacyScore": { "type": "number", "minimum": 0, "maximum": 100 }
+      }
+    },
+    "dataGeneration": {
+      "type": "object",
+      "properties": {
+        "strategy": {
+          "type": "string",
+          "enum": ["synthetic", "anonymized", "subset", "mock", "hybrid"],
+          "description": "Data generation strategy"
+        },
+        "recordsGenerated": { "type": "integer", "minimum": 0 },
+        "throughput": {
+          "type": "number",
+          "description": "Records per second"
+        },
+        "tables": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/tableGeneration"
+          }
+        },
+        "referentialIntegrity": { "type": "boolean" },
+        "seed": { "type": "integer", "description": "Random seed for reproducibility" }
+      }
+    },
+    "tableGeneration": {
+      "type": "object",
+      "required": ["name", "recordCount"],
+      "properties": {
+        "name": { "type": "string" },
+        "recordCount": { "type": "integer", "minimum": 0 },
+        "constraints": {
+          "type": "object",
+          "additionalProperties": true
+        },
+        "status": { "type": "string", "enum": ["success", "partial", "failed"] }
+      }
+    },
+    "privacyCompliance": {
+      "type": "object",
+      "properties": {
+        "gdprCompliant": { "type": "boolean" },
+        "ccpaCompliant": { "type": "boolean" },
+        "piiDetected": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/piiField"
+          },
+          "description": "PII fields detected"
+        },
+        "piiHandling": {
+          "type": "object",
+          "properties": {
+            "masked": { "type": "integer" },
+            "hashed": { "type": "integer" },
+            "tokenized": { "type": "integer" },
+            "removed": { "type": "integer" }
+          }
+        },
+        "dataRetention": {
+          "type": "object",
+          "properties": {
+            "policy": { "type": "string" },
+            "expirationDays": { "type": "integer" }
+          }
+        },
+        "auditLog": { "type": "boolean" }
+      }
+    },
+    "piiField": {
+      "type": "object",
+      "required": ["field", "piiType"],
+      "properties": {
+        "field": { "type": "string" },
+        "piiType": {
+          "type": "string",
+          "enum": ["email", "phone", "ssn", "address", "name", "dob", "financial", "health", "other"]
+        },
+        "handling": {
+          "type": "string",
+          "enum": ["masked", "hashed", "tokenized", "removed", "synthetic"]
+        },
+        "location": { "type": "string" }
+      }
+    },
+    "dataQuality": {
+      "type": "object",
+      "properties": {
+        "completeness": { "type": "number", "minimum": 0, "maximum": 100 },
+        "uniqueness": { "type": "number", "minimum": 0, "maximum": 100 },
+        "validity": { "type": "number", "minimum": 0, "maximum": 100 },
+        "consistency": { "type": "number", "minimum": 0, "maximum": 100 },
+        "overallScore": { "type": "number", "minimum": 0, "maximum": 100 },
+        "issues": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+    "schemaResult": {
+      "type": "object",
+      "required": ["schema", "status"],
+      "properties": {
+        "schema": { "type": "string" },
+        "status": { "type": "string", "enum": ["valid", "invalid", "partial"] },
+        "recordsValidated": { "type": "integer" },
+        "validationErrors": { "type": "integer" }
+      }
+    },
+    "dataFinding": {
+      "type": "object",
+      "required": ["id", "title", "severity", "category"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^DATA-\\d{3,6}$" },
+        "title": { "type": "string", "minLength": 5, "maxLength": 200 },
+        "description": { "type": "string", "maxLength": 2000 },
+        "severity": { "type": "string", "enum": ["critical", "high", "medium", "low", "info"] },
+        "category": {
+          "type": "string",
+          "enum": ["privacy", "quality", "schema", "integrity", "performance", "compliance"]
+        },
+        "affectedTables": { "type": "array", "items": { "type": "string" } },
+        "remediation": { "type": "string" }
+      }
+    },
+    "dataMetrics": {
+      "type": "object",
+      "properties": {
+        "totalRecords": { "type": "integer", "minimum": 0 },
+        "tablesProcessed": { "type": "integer", "minimum": 0 },
+        "piiFieldsHandled": { "type": "integer", "minimum": 0 },
+        "dataQualityScore": { "type": "number", "minimum": 0, "maximum": 100 },
+        "generationTimeMs": { "type": "integer", "minimum": 0 },
+        "throughputPerSec": { "type": "number", "minimum": 0 }
+      }
+    },
+    "recommendation": {
+      "type": "object",
+      "required": ["id", "title", "priority"],
+      "properties": {
+        "id": { "type": "string", "pattern": "^REC-\\d{3,6}$" },
+        "title": { "type": "string" },
+        "description": { "type": "string" },
+        "priority": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
+        "effort": { "type": "string", "enum": ["trivial", "low", "medium", "high", "major"] }
+      }
+    },
+    "artifact": {
+      "type": "object",
+      "required": ["type", "path"],
+      "properties": {
+        "type": { "type": "string", "enum": ["data", "report", "schema", "log", "config"] },
+        "path": { "type": "string" },
+        "format": { "type": "string", "enum": ["json", "csv", "sql", "yaml", "html"] }
+      }
+    }
+  }
+}

package/.claude/skills/test-data-management/scripts/validate.sh

@@ -0,0 +1,137 @@
+#!/bin/bash
+# =============================================================================
+# AQE Test Data Management Skill Validator v1.0.0
+# Validates test data generation and privacy compliance output
+# =============================================================================
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+PROJECT_ROOT="$(cd "$SKILL_DIR/../../.." && pwd)"
+
+for lib_path in \
+  "$PROJECT_ROOT/.claude/skills/.validation/templates/validator-lib.sh" \
+  "$SKILL_DIR/scripts/validator-lib.sh"; do
+  if [[ -f "$lib_path" ]]; then
+    source "$lib_path"
+    break
+  fi
+done
+
+SKILL_NAME="test-data-management"
+SKILL_VERSION="1.0.0"
+REQUIRED_TOOLS=("jq")
+OPTIONAL_TOOLS=("faker" "ajv" "jsonschema" "python3")
+SCHEMA_PATH="$SKILL_DIR/schemas/output.json"
+
+REQUIRED_FIELDS=("skillName" "status" "output" "output.dataGeneration" "output.privacyCompliance" "output.metrics")
+REQUIRED_NON_EMPTY_FIELDS=("output.summary")
+MUST_CONTAIN_TERMS=("data")
+MUST_NOT_CONTAIN_TERMS=("TODO" "placeholder" "FIXME")
+ENUM_VALIDATIONS=(".status:success,partial,failed,skipped")
+
+OUTPUT_FILE=""
+SELF_TEST=false
+VERBOSE=false
+JSON_ONLY=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --self-test) SELF_TEST=true; shift ;;
+    --verbose|-v) VERBOSE=true; export AQE_DEBUG=1; shift ;;
+    --json) JSON_ONLY=true; shift ;;
+    --list-tools)
+      echo "Test Data Management Validator Tools"
+      for tool in "${REQUIRED_TOOLS[@]}"; do
+        command_exists "$tool" && echo "  [OK] $tool" || echo "  [MISSING] $tool"
+      done
+      exit 0 ;;
+    -h|--help) echo "Usage: $0 <output-file> [--self-test] [--verbose] [--json]"; exit 0 ;;
+    -*) error "Unknown option: $1"; exit 1 ;;
+    *) OUTPUT_FILE="$1"; shift ;;
+  esac
+done
+
+if [[ "$SELF_TEST" == "true" ]]; then
+  echo "Running $SKILL_NAME Validator Self-Test..."
+  for tool in "${REQUIRED_TOOLS[@]}"; do
+    command_exists "$tool" && success "Tool: $tool" || error "Missing: $tool"
+  done
+  [[ -f "$SCHEMA_PATH" ]] && success "Schema exists" || error "Schema missing"
+  exit 0
+fi
+
+validate_skill_specific() {
+  local output_file="$1"
+  local has_errors=false
+
+  # Check data generation strategy
+  local strategy
+  strategy=$(json_get "$output_file" ".output.dataGeneration.strategy" 2>/dev/null)
+  if [[ -n "$strategy" ]] && [[ "$strategy" != "null" ]]; then
+    success "Data generation strategy: $strategy"
+  fi
+
+  # Check records generated
+  local records
+  records=$(json_get "$output_file" ".output.dataGeneration.recordsGenerated" 2>/dev/null)
+  [[ -n "$records" ]] && [[ "$records" != "null" ]] && success "Records generated: $records"
+
+  # Check privacy compliance
+  local gdpr_compliant ccpa_compliant
+  gdpr_compliant=$(json_get "$output_file" ".output.privacyCompliance.gdprCompliant" 2>/dev/null)
+  ccpa_compliant=$(json_get "$output_file" ".output.privacyCompliance.ccpaCompliant" 2>/dev/null)
+
+  if [[ "$gdpr_compliant" == "true" ]]; then
+    success "GDPR compliant"
+  elif [[ "$gdpr_compliant" == "false" ]]; then
+    warn "Not GDPR compliant"
+  fi
+
+  # Check PII handling
+  local pii_count
+  pii_count=$(json_count "$output_file" ".output.privacyCompliance.piiDetected" 2>/dev/null)
+  if [[ -n "$pii_count" ]] && [[ "$pii_count" -gt 0 ]]; then
+    success "PII fields detected and handled: $pii_count"
+  fi
+
+  # Check data quality
+  local quality_score
+  quality_score=$(json_get "$output_file" ".output.dataQuality.overallScore" 2>/dev/null)
+  [[ -n "$quality_score" ]] && [[ "$quality_score" != "null" ]] && success "Data quality score: $quality_score"
+
+  # Check finding format
+  local finding_count
+  finding_count=$(json_count "$output_file" ".output.findings" 2>/dev/null)
+  if [[ -n "$finding_count" ]] && [[ "$finding_count" -gt 0 ]]; then
+    local first_id
+    first_id=$(json_get "$output_file" ".output.findings[0].id" 2>/dev/null)
+    [[ "$first_id" =~ ^DATA-[0-9]+$ ]] && success "Finding ID format valid" || warn "Finding ID should match DATA-XXX"
+  fi
+
+  [[ "$has_errors" == "true" ]] && return 1
+  success "Test data management validation passed"
+  return 0
+}
+
+# Main validation
+[[ -z "$OUTPUT_FILE" ]] && { error "No output file specified"; exit 1; }
+[[ ! -f "$OUTPUT_FILE" ]] && { error "File not found: $OUTPUT_FILE"; exit 1; }
+
+for tool in "${REQUIRED_TOOLS[@]}"; do
+  command_exists "$tool" || { error "Missing tool: $tool"; exit 2; }
+done
+
+validate_json "$OUTPUT_FILE" || { error "Invalid JSON"; exit 1; }
+[[ -f "$SCHEMA_PATH" ]] && validate_json_schema "$SCHEMA_PATH" "$OUTPUT_FILE"
+
+for field in "${REQUIRED_FIELDS[@]}"; do
+  value=$(json_get "$OUTPUT_FILE" ".$field" 2>/dev/null)
+  [[ -z "$value" ]] || [[ "$value" == "null" ]] && { error "Missing field: $field"; exit 1; }
+done
+
+validate_skill_specific "$OUTPUT_FILE" || exit 1
+
+success "Validation PASSED"
+exit 0

package/.claude/skills/test-design-techniques/SKILL.md

@@ -11,6 +11,12 @@ last_optimized: 2025-12-02
 dependencies: []
 quick_reference_card: true
 tags: [test-design, bva, equivalence-partitioning, decision-tables, pairwise, state-transition]
+trust_tier: 3
+validation:
+  schema_path: schemas/output.json
+  validator_path: scripts/validate.sh
+  eval_path: evals/test-design-techniques.yaml
+
 ---
 
 # Test Design Techniques

package/.claude/skills/test-design-techniques/evals/test-design-techniques.yaml

@@ -0,0 +1,142 @@
+skill: test-design-techniques
+version: 1.0.0
+description: >
+  Evaluation suite for test-design-techniques skill.
+  Tests generation of test design techniques including boundary value analysis,
+  equivalence partitioning, pairwise testing, and state machine modeling.
+
+models_to_test:
+  - claude-3.5-sonnet
+  - claude-3-haiku
+
+mcp_integration:
+  enabled: true
+  namespace: skill-validation
+  query_patterns: true
+  track_outcomes: true
+  store_patterns: true
+  share_learning: true
+  target_agents:
+    - qe-learning-coordinator
+
+learning:
+  store_success_patterns: true
+  pattern_ttl_days: 90
+  min_confidence_to_store: 0.7
+
+result_format:
+  json_output: true
+  include_timing: true
+
+setup:
+  required_tools:
+    - jq
+
+test_cases:
+  - id: tc001_boundary_value_analysis
+    description: "Skill generates boundary value analysis test cases"
+    category: core
+    priority: critical
+
+    input:
+      requirement: "Age field must accept values 18-65"
+      context:
+        technique: "boundary_value_analysis"
+
+    expected_output:
+      must_contain:
+        - "boundary"
+        - "test case"
+
+    validation:
+      schema_check: true
+
+  - id: tc002_equivalence_partitioning
+    description: "Skill applies equivalence partitioning technique"
+    category: core
+    priority: critical
+
+    input:
+      requirement: "User status: active, inactive, suspended"
+      context:
+        technique: "equivalence_partitioning"
+
+    expected_output:
+      must_contain:
+        - "equivalence"
+        - "partition"
+
+    validation:
+      schema_check: true
+
+  - id: tc003_pairwise_testing
+    description: "Skill generates pairwise test combinations"
+    category: core
+    priority: high
+
+    input:
+      parameters:
+        - browser: "Chrome, Firefox, Safari"
+        - os: "Windows, macOS, Linux"
+      context:
+        technique: "pairwise"
+
+    expected_output:
+      must_contain:
+        - "pair"
+        - "combination"
+
+    validation:
+      schema_check: true
+      allow_partial: true
+
+  - id: tc004_state_machine_testing
+    description: "Skill models state transitions for testing"
+    category: core
+    priority: high
+
+    input:
+      workflow: "Order processing: pending -> processing -> shipped -> delivered"
+      context:
+        technique: "state_machine"
+
+    expected_output:
+      must_contain:
+        - "state"
+        - "transition"
+
+    validation:
+      schema_check: true
+      allow_partial: true
+
+  - id: tc005_decision_table_testing
+    description: "Skill creates decision table for business logic"
+    category: core
+    priority: high
+
+    input:
+      rules: "Discount applies if customer is VIP AND order > $100"
+      context:
+        technique: "decision_table"
+
+    expected_output:
+      must_contain:
+        - "decision"
+        - "table"
+
+    validation:
+      schema_check: true
+      allow_partial: true
+
+success_criteria:
+  pass_rate: 0.8
+  critical_pass_rate: 1.0
+  avg_reasoning_quality: 0.7
+  max_execution_time_ms: 300000
+  cross_model_variance: 0.15
+
+metadata:
+  author: "qe-test-architect"
+  created: "2026-02-02"
+  last_updated: "2026-02-02"
+  coverage_target: "Boundary analysis, equivalence partitioning, pairwise, state machine, decision tables"