agentic-qe 3.4.1 → 3.4.2

package/.claude/skills/n8n-expression-testing/schemas/output.json

@@ -0,0 +1,369 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agentic-qe.dev/schemas/skills/n8n-expression-testing/output.json",
+  "title": "N8N Expression Testing Skill Output Schema",
+  "description": "Schema for n8n-expression-testing skill output. Validates n8n expression syntax, JavaScript evaluation, and data transformation testing.",
+  "type": "object",
+  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
+  "properties": {
+    "skillName": {
+      "type": "string",
+      "const": "n8n-expression-testing"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["success", "partial", "failed", "skipped"]
+    },
+    "trustTier": {
+      "type": "integer",
+      "const": 3
+    },
+    "output": {
+      "type": "object",
+      "required": ["summary", "expressionResults", "nodeTests"],
+      "properties": {
+        "summary": {
+          "type": "string",
+          "minLength": 20,
+          "maxLength": 2000,
+          "description": "Summary of expression testing analysis"
+        },
+        "expressionResults": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/expressionResult"
+          },
+          "minItems": 0,
+          "maxItems": 500,
+          "description": "Results of expression evaluations"
+        },
+        "nodeTests": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/nodeTest"
+          },
+          "maxItems": 200,
+          "description": "Node-specific test cases"
+        },
+        "workflowValidation": {
+          "$ref": "#/$defs/workflowValidation",
+          "description": "Workflow-level validation results"
+        },
+        "syntaxErrors": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/syntaxError"
+          },
+          "description": "Expression syntax errors found"
+        },
+        "dataTransformations": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/dataTransformation"
+          },
+          "description": "Data transformation test cases"
+        },
+        "recommendations": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/recommendation"
+          },
+          "maxItems": 50
+        },
+        "metrics": {
+          "$ref": "#/$defs/metrics"
+        }
+      }
+    },
+    "metadata": {
+      "$ref": "#/$defs/metadata"
+    },
+    "validation": {
+      "$ref": "#/$defs/validationResult"
+    },
+    "learning": {
+      "$ref": "#/$defs/learningData"
+    }
+  },
+  "$defs": {
+    "expressionResult": {
+      "type": "object",
+      "required": ["id", "expression", "status"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^EXPR-\\d{3,6}$"
+        },
+        "expression": {
+          "type": "string",
+          "maxLength": 5000,
+          "description": "The n8n expression being tested"
+        },
+        "expressionType": {
+          "type": "string",
+          "enum": ["simple", "javascript", "template", "function", "mixed"],
+          "description": "Type of n8n expression"
+        },
+        "status": {
+          "type": "string",
+          "enum": ["valid", "invalid", "warning", "error"]
+        },
+        "input": {
+          "type": "object",
+          "description": "Input data for expression evaluation"
+        },
+        "expectedOutput": {
+          "description": "Expected result of expression"
+        },
+        "actualOutput": {
+          "description": "Actual result of expression evaluation"
+        },
+        "passed": {
+          "type": "boolean"
+        },
+        "errorMessage": {
+          "type": "string",
+          "maxLength": 1000
+        },
+        "nodeContext": {
+          "type": "string",
+          "description": "The node where this expression is used"
+        },
+        "dataPath": {
+          "type": "string",
+          "description": "JSON path in workflow data"
+        }
+      }
+    },
+    "nodeTest": {
+      "type": "object",
+      "required": ["nodeId", "nodeName", "nodeType"],
+      "properties": {
+        "nodeId": {
+          "type": "string"
+        },
+        "nodeName": {
+          "type": "string"
+        },
+        "nodeType": {
+          "type": "string",
+          "description": "n8n node type (e.g., n8n-nodes-base.set, n8n-nodes-base.code)"
+        },
+        "expressionCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "passedExpressions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "failedExpressions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "coverage": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100
+        },
+        "issues": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "workflowValidation": {
+      "type": "object",
+      "required": ["workflowId", "valid"],
+      "properties": {
+        "workflowId": {
+          "type": "string"
+        },
+        "workflowName": {
+          "type": "string"
+        },
+        "valid": {
+          "type": "boolean"
+        },
+        "totalNodes": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "testedNodes": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "totalExpressions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "validExpressions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "invalidExpressions": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "overallScore": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100
+        },
+        "grade": {
+          "type": "string",
+          "pattern": "^[A-F][+-]?$"
+        }
+      }
+    },
+    "syntaxError": {
+      "type": "object",
+      "required": ["expression", "error"],
+      "properties": {
+        "expression": {
+          "type": "string"
+        },
+        "error": {
+          "type": "string"
+        },
+        "line": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "column": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "nodeName": {
+          "type": "string"
+        },
+        "severity": {
+          "type": "string",
+          "enum": ["error", "warning", "info"]
+        },
+        "suggestion": {
+          "type": "string"
+        }
+      }
+    },
+    "dataTransformation": {
+      "type": "object",
+      "required": ["id", "description", "input", "expectedOutput"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^TRANS-\\d{3,6}$"
+        },
+        "description": {
+          "type": "string"
+        },
+        "input": {
+          "type": "object"
+        },
+        "expectedOutput": {},
+        "actualOutput": {},
+        "expression": {
+          "type": "string"
+        },
+        "passed": {
+          "type": "boolean"
+        },
+        "transformationType": {
+          "type": "string",
+          "enum": ["map", "filter", "reduce", "split", "merge", "custom"]
+        }
+      }
+    },
+    "recommendation": {
+      "type": "object",
+      "required": ["id", "title", "priority"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^REC-\\d{3,6}$"
+        },
+        "title": {
+          "type": "string",
+          "maxLength": 200
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 2000
+        },
+        "priority": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low"]
+        },
+        "category": {
+          "type": "string",
+          "enum": ["syntax", "performance", "security", "best-practice", "data-handling"]
+        },
+        "codeExample": {
+          "type": "string",
+          "maxLength": 5000
+        }
+      }
+    },
+    "metrics": {
+      "type": "object",
+      "properties": {
+        "totalExpressions": { "type": "integer", "minimum": 0 },
+        "validExpressions": { "type": "integer", "minimum": 0 },
+        "invalidExpressions": { "type": "integer", "minimum": 0 },
+        "passRate": { "type": "number", "minimum": 0, "maximum": 100 },
+        "nodesAnalyzed": { "type": "integer", "minimum": 0 },
+        "syntaxErrorCount": { "type": "integer", "minimum": 0 },
+        "executionTimeMs": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "executionTimeMs": { "type": "integer", "minimum": 0 },
+        "toolsUsed": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "agentId": {
+          "type": "string",
+          "pattern": "^qe-[a-z][a-z0-9-]*$"
+        },
+        "n8nVersion": {
+          "type": "string",
+          "description": "n8n version being tested against"
+        },
+        "workflowPath": {
+          "type": "string"
+        }
+      }
+    },
+    "validationResult": {
+      "type": "object",
+      "properties": {
+        "schemaValid": { "type": "boolean" },
+        "contentValid": { "type": "boolean" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "learningData": {
+      "type": "object",
+      "properties": {
+        "patternsDetected": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "reward": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  }
+}

package/.claude/skills/n8n-expression-testing/scripts/validate.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+# =============================================================================
+# AQE Skill Validator: n8n-expression-testing v1.0.0
+# Validates n8n expression testing skill output per ADR-056
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+PROJECT_ROOT="$(cd "$SKILL_DIR/../../.." && pwd)"
+
+# Source validator library
+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="n8n-expression-testing"
+SKILL_VERSION="1.0.0"
+REQUIRED_TOOLS=("jq")
+OPTIONAL_TOOLS=("node")
+SCHEMA_PATH="$SKILL_DIR/schemas/output.json"
+
+REQUIRED_FIELDS=("skillName" "status" "output" "output.summary" "output.expressionResults" "output.nodeTests")
+REQUIRED_NON_EMPTY_FIELDS=("output.summary")
+MUST_CONTAIN_TERMS=("expression" "n8n")
+MUST_NOT_CONTAIN_TERMS=("TODO" "FIXME" "placeholder")
+ENUM_VALIDATIONS=(".status:success,partial,failed,skipped")
+
+# N8N Expression-specific validation
+validate_skill_specific() {
+  local output_file="$1"
+  local has_errors=false
+
+  # Validate expression results have required structure
+  local expr_count
+  expr_count=$(jq '.output.expressionResults | length' "$output_file" 2>/dev/null || echo "0")
+
+  if [[ "$expr_count" -gt 0 ]]; then
+    # Check expression result structure
+    local invalid_exprs
+    invalid_exprs=$(jq '[.output.expressionResults[]? | select(.id == null or .expression == null or .status == null)] | length' "$output_file" 2>/dev/null || echo "0")
+
+    if [[ "$invalid_exprs" -gt 0 ]]; then
+      warn "$invalid_exprs expression result(s) missing required fields (id, expression, status)"
+    fi
+
+    # Validate expression IDs follow pattern
+    local invalid_ids
+    invalid_ids=$(jq '[.output.expressionResults[]?.id // empty | select(test("^EXPR-[0-9]{3,6}$") | not)] | length' "$output_file" 2>/dev/null || echo "0")
+
+    if [[ "$invalid_ids" -gt 0 ]]; then
+      warn "$invalid_ids expression(s) have invalid ID format (should be EXPR-NNN)"
+    fi
+
+    # Validate expression status values
+    local valid_statuses="valid invalid warning error"
+    local statuses
+    statuses=$(jq -r '.output.expressionResults[]?.status // empty' "$output_file" 2>/dev/null || true)
+
+    for status in $statuses; do
+      if ! echo "$valid_statuses" | grep -qw "$status"; then
+        error "Invalid expression status: $status"
+        has_errors=true
+      fi
+    done
+  fi
+
+  # Validate node tests
+  local node_count
+  node_count=$(jq '.output.nodeTests | length' "$output_file" 2>/dev/null || echo "0")
+
+  if [[ "$node_count" -gt 0 ]]; then
+    local invalid_nodes
+    invalid_nodes=$(jq '[.output.nodeTests[]? | select(.nodeId == null or .nodeName == null or .nodeType == null)] | length' "$output_file" 2>/dev/null || echo "0")
+
+    if [[ "$invalid_nodes" -gt 0 ]]; then
+      warn "$invalid_nodes node test(s) missing required fields"
+    fi
+  fi
+
+  # Validate workflow validation if present
+  local has_workflow
+  has_workflow=$(jq 'has("output") and (.output | has("workflowValidation"))' "$output_file" 2>/dev/null)
+
+  if [[ "$has_workflow" == "true" ]]; then
+    local wf_valid
+    wf_valid=$(jq '.output.workflowValidation | has("workflowId") and has("valid")' "$output_file" 2>/dev/null)
+
+    if [[ "$wf_valid" != "true" ]]; then
+      warn "Workflow validation missing required fields (workflowId, valid)"
+    fi
+  fi
+
+  if [[ "$has_errors" == "true" ]]; then
+    return 1
+  fi
+
+  success "N8N expression testing validation passed"
+  return 0
+}
+
+# Main validation (delegate to common pattern)
+source "$PROJECT_ROOT/.claude/skills/.validation/templates/validator-main.sh" 2>/dev/null || {
+  # Fallback if main template not found
+  OUTPUT_FILE="${1:-}"
+
+  # Handle --self-test flag
+  if [[ "$OUTPUT_FILE" == "--self-test" ]]; then
+    echo "=== Self-Test: $SKILL_NAME v$SKILL_VERSION ==="
+    echo "[PASS] Required tool: jq"
+    if command -v node &>/dev/null; then
+      echo "[PASS] Optional tool: node"
+    else
+      echo "[WARN] Optional tool missing: node"
+    fi
+    if [[ -f "$SCHEMA_PATH" ]]; then
+      echo "[PASS] Schema file exists"
+      if jq empty "$SCHEMA_PATH" 2>/dev/null; then
+        echo "[PASS] Schema is valid JSON"
+      else
+        echo "[FAIL] Schema is invalid JSON"
+        exit 1
+      fi
+    else
+      echo "[WARN] Schema file not found"
+    fi
+    echo "[PASS] Self-test completed"
+    exit 0
+  fi
+
+  if [[ -z "$OUTPUT_FILE" ]]; then
+    echo "Usage: $0 <output-file> | --self-test"
+    exit 1
+  fi
+
+  if [[ ! -f "$OUTPUT_FILE" ]]; then
+    echo "ERROR: File not found: $OUTPUT_FILE"
+    exit 1
+  fi
+
+  echo "Validating $SKILL_NAME output..."
+
+  # Basic JSON validation
+  if ! jq empty "$OUTPUT_FILE" 2>/dev/null; then
+    echo "ERROR: Invalid JSON"
+    exit 1
+  fi
+
+  # Run skill-specific validation
+  if validate_skill_specific "$OUTPUT_FILE"; then
+    echo "PASSED: $SKILL_NAME validation"
+    exit 0
+  else
+    echo "FAILED: $SKILL_NAME validation"
+    exit 1
+  fi
+}

package/.claude/skills/n8n-integration-testing-patterns/SKILL.md

@@ -11,6 +11,12 @@ last_optimized: 2025-12-15
 dependencies: []
 quick_reference_card: true
 tags: [n8n, integration, api, authentication, oauth, rate-limiting, testing]
+trust_tier: 3
+validation:
+  schema_path: schemas/output.json
+  validator_path: scripts/validate.sh
+  eval_path: evals/n8n-integration-testing-patterns.yaml
+
 ---
 
 # n8n Integration Testing Patterns