@agentic-qe/v3 3.0.0-alpha.10

package/assets/skills/v3-qe-contract-testing/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: "V3 QE Contract Testing"
+description: "Consumer-driven contract testing for APIs including REST, GraphQL, and event-driven systems with schema validation."
+---
+
+# V3 QE Contract Testing
+
+## Purpose
+
+Guide the use of v3's contract testing capabilities including consumer-driven contracts, schema validation, backward compatibility checking, and API versioning verification.
+
+## Activation
+
+- When testing API contracts
+- When validating schema changes
+- When checking backward compatibility
+- When testing GraphQL APIs
+- When verifying event schemas
+
+## Quick Start
+
+```bash
+# Generate contract from API
+aqe-v3 contract generate --api openapi.yaml --output contracts/
+
+# Verify provider against contracts
+aqe-v3 contract verify --provider http://localhost:3000 --contracts contracts/
+
+# Check breaking changes
+aqe-v3 contract breaking --old api-v1.yaml --new api-v2.yaml
+
+# Test GraphQL schema
+aqe-v3 contract graphql --schema schema.graphql --operations queries/
+```
+
+## Agent Workflow
+
+```typescript
+// Contract generation
+Task("Generate API contracts", `
+  Analyze the REST API and generate consumer contracts:
+  - Parse OpenAPI specification
+  - Identify critical endpoints
+  - Generate Pact contracts
+  - Include example requests/responses
+  Output to contracts/ directory.
+`, "v3-qe-api-contract")
+
+// Breaking change detection
+Task("Check API compatibility", `
+  Compare API v2.0 against v1.0:
+  - Detect removed endpoints
+  - Check parameter changes
+  - Verify response schema changes
+  - Identify deprecations
+  Report breaking vs non-breaking changes.
+`, "v3-qe-api-compatibility")
+```
+
+## Contract Testing Types
+
+### 1. Consumer-Driven Contracts (Pact)
+
+```typescript
+await contractTester.consumerDriven({
+  consumer: 'web-app',
+  provider: 'user-service',
+  contracts: 'contracts/web-app-user-service.json',
+  verification: {
+    providerBaseUrl: 'http://localhost:3000',
+    providerStates: providerStateHandlers,
+    publishResults: true
+  }
+});
+```
+
+### 2. Schema Validation
+
+```typescript
+await contractTester.validateSchema({
+  type: 'openapi',
+  schema: 'api/openapi.yaml',
+  requests: actualRequests,
+  validation: {
+    requestBody: true,
+    responseBody: true,
+    headers: true,
+    statusCodes: true
+  }
+});
+```
+
+### 3. GraphQL Contract Testing
+
+```typescript
+await graphqlTester.testContracts({
+  schema: 'schema.graphql',
+  operations: 'queries/**/*.graphql',
+  validation: {
+    queryValidity: true,
+    responseShapes: true,
+    nullability: true,
+    deprecations: true
+  }
+});
+```
+
+### 4. Event Contract Testing
+
+```typescript
+await contractTester.eventContracts({
+  schema: 'events/schemas/',
+  events: {
+    'user.created': {
+      schema: 'UserCreatedEvent.json',
+      examples: ['examples/user-created.json']
+    },
+    'order.completed': {
+      schema: 'OrderCompletedEvent.json',
+      examples: ['examples/order-completed.json']
+    }
+  },
+  compatibility: 'backward'
+});
+```
+
+## Breaking Change Detection
+
+```yaml
+breaking_changes:
+  always_breaking:
+    - endpoint_removed
+    - required_param_added
+    - response_field_removed
+    - type_changed
+
+  potentially_breaking:
+    - optional_param_removed
+    - response_field_added
+    - enum_value_removed
+
+  non_breaking:
+    - endpoint_added
+    - optional_param_added
+    - response_field_made_optional
+    - documentation_changed
+```
+
+## Contract Report
+
+```typescript
+interface ContractReport {
+  summary: {
+    contracts: number;
+    passed: number;
+    failed: number;
+    warnings: number;
+  };
+  consumers: {
+    name: string;
+    contracts: ContractResult[];
+    compatibility: 'compatible' | 'breaking' | 'unknown';
+  }[];
+  breakingChanges: {
+    type: string;
+    location: string;
+    description: string;
+    impact: 'high' | 'medium' | 'low';
+    migration: string;
+  }[];
+  deprecations: {
+    item: string;
+    deprecatedIn: string;
+    removeIn: string;
+    replacement: string;
+  }[];
+}
+```
+
+## CI/CD Integration
+
+```yaml
+contract_verification:
+  consumer_side:
+    - generate_contracts
+    - publish_to_broker
+    - can_i_deploy_check
+
+  provider_side:
+    - fetch_contracts_from_broker
+    - verify_against_provider
+    - publish_results
+
+  pre_release:
+    - check_breaking_changes
+    - verify_all_consumers
+    - update_compatibility_matrix
+```
+
+## Pact Broker Integration
+
+```typescript
+await contractTester.withBroker({
+  brokerUrl: 'https://pact-broker.example.com',
+  auth: { token: process.env.PACT_TOKEN },
+  operations: {
+    publish: true,
+    canIDeploy: true,
+    webhooks: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-api-contract, v3-qe-api-compatibility, v3-qe-graphql-tester
+**Coordinator**: v3-qe-contract-coordinator
+**Related Skills**: v3-qe-test-generation, v3-qe-security-compliance

package/assets/skills/v3-qe-coverage-analysis/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: "V3 QE Coverage Analysis"
+description: "O(log n) sublinear coverage gap detection with risk-weighted analysis and intelligent test prioritization."
+---
+
+# V3 QE Coverage Analysis
+
+## Purpose
+
+Guide the use of v3's advanced coverage analysis capabilities including sublinear gap detection algorithms, risk-weighted coverage scoring, and intelligent test prioritization based on code criticality.
+
+## Activation
+
+- When analyzing test coverage
+- When identifying coverage gaps
+- When prioritizing testing effort
+- When setting coverage targets
+- When assessing code risk
+
+## Quick Start
+
+```bash
+# Analyze coverage with gap detection
+aqe-v3 coverage analyze --source src/ --tests tests/
+
+# Find high-risk uncovered code
+aqe-v3 coverage gaps --risk-weighted --threshold 80
+
+# Generate coverage report
+aqe-v3 coverage report --format html --output coverage-report/
+
+# Compare coverage between branches
+aqe-v3 coverage diff --base main --head feature-branch
+```
+
+## Agent Workflow
+
+```typescript
+// Comprehensive coverage analysis
+Task("Analyze coverage gaps", `
+  Perform O(log n) coverage analysis on src/:
+  - Calculate statement, branch, function coverage
+  - Identify uncovered critical paths
+  - Risk-weight gaps by code complexity and change frequency
+  - Recommend tests to write for maximum coverage impact
+`, "v3-qe-coverage-specialist")
+
+// Risk-based prioritization
+Task("Prioritize coverage effort", `
+  Analyze coverage gaps and prioritize by:
+  - Business criticality (payment, auth, data)
+  - Code complexity (cyclomatic > 10)
+  - Recent bug history
+  - Change frequency
+  Output prioritized list of files needing tests.
+`, "v3-qe-coverage-analyzer")
+```
+
+## Analysis Strategies
+
+### 1. Sublinear Gap Detection
+
+```typescript
+await coverageAnalyzer.detectGaps({
+  algorithm: 'sublinear',  // O(log n) complexity
+  source: 'src/**/*.ts',
+  metrics: ['statement', 'branch', 'function'],
+  sampling: {
+    enabled: true,
+    confidence: 0.95,
+    maxSamples: 1000
+  }
+});
+```
+
+### 2. Risk-Weighted Coverage
+
+```typescript
+await coverageAnalyzer.riskWeightedAnalysis({
+  coverage: coverageReport,
+  riskFactors: {
+    complexity: { weight: 0.3, threshold: 10 },
+    changeFrequency: { weight: 0.25, window: '90d' },
+    bugHistory: { weight: 0.25, window: '180d' },
+    criticality: { weight: 0.2, tags: ['payment', 'auth'] }
+  },
+  output: {
+    riskScore: true,
+    prioritizedGaps: true
+  }
+});
+```
+
+### 3. Differential Coverage
+
+```typescript
+await coverageAnalyzer.diffCoverage({
+  base: 'main',
+  head: 'feature-branch',
+  requirements: {
+    newCode: 80,           // New code must have 80% coverage
+    modifiedCode: 'maintain',  // Don't decrease existing
+    deletedCode: 'ignore'
+  }
+});
+```
+
+## Coverage Thresholds
+
+```yaml
+thresholds:
+  global:
+    statements: 80
+    branches: 75
+    functions: 85
+    lines: 80
+
+  per_file:
+    min_statements: 70
+    critical_paths: 90
+
+  new_code:
+    statements: 85
+    branches: 80
+
+  exceptions:
+    - path: "src/migrations/**"
+      reason: "Database migrations"
+    - path: "src/generated/**"
+      reason: "Auto-generated code"
+```
+
+## Coverage Report
+
+```typescript
+interface CoverageAnalysis {
+  summary: {
+    statements: { covered: number; total: number; percentage: number };
+    branches: { covered: number; total: number; percentage: number };
+    functions: { covered: number; total: number; percentage: number };
+  };
+  gaps: {
+    file: string;
+    uncoveredLines: number[];
+    uncoveredBranches: BranchInfo[];
+    riskScore: number;
+    suggestedTests: string[];
+  }[];
+  trends: {
+    period: string;
+    coverageChange: number;
+    newGaps: number;
+    closedGaps: number;
+  };
+  recommendations: {
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    file: string;
+    action: string;
+    expectedImpact: number;
+  }[];
+}
+```
+
+## Quality Gates
+
+```yaml
+quality_gates:
+  coverage:
+    block_merge:
+      - new_code_coverage < 80
+      - coverage_regression > 5
+      - critical_path_uncovered
+
+    warn:
+      - overall_coverage < 75
+      - branch_coverage < 70
+
+    metrics:
+      - track_trends: true
+      - alert_on_decline: 3  # consecutive PRs
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-coverage-specialist, v3-qe-coverage-analyzer, v3-qe-gap-detector
+**Coordinator**: v3-qe-coverage-coordinator
+**Related Skills**: v3-qe-test-generation, v3-qe-quality-assessment

package/assets/skills/v3-qe-defect-intelligence/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: "V3 QE Defect Intelligence"
+description: "AI-powered defect prediction, pattern learning, and root cause analysis for proactive quality management."
+---
+
+# V3 QE Defect Intelligence
+
+## Purpose
+
+Guide the use of v3's defect intelligence capabilities including ML-based defect prediction, pattern recognition from historical data, and automated root cause analysis.
+
+## Activation
+
+- When predicting defect-prone code
+- When analyzing failure patterns
+- When performing root cause analysis
+- When learning from past defects
+- When prioritizing testing based on risk
+
+## Quick Start
+
+```bash
+# Predict defects in changed code
+aqe-v3 defect predict --changes HEAD~5..HEAD
+
+# Analyze failure patterns
+aqe-v3 defect patterns --period 90d --min-occurrences 3
+
+# Root cause analysis
+aqe-v3 defect rca --failure "test/auth.test.ts:45"
+
+# Learn from resolved defects
+aqe-v3 defect learn --source jira --status resolved
+```
+
+## Agent Workflow
+
+```typescript
+// Defect prediction
+Task("Predict defect-prone code", `
+  Analyze PR #456 changes and predict defect likelihood:
+  - Historical defect correlation
+  - Code complexity factors
+  - Author experience with module
+  - Test coverage gaps
+  Flag high-risk changes requiring extra review.
+`, "v3-qe-defect-predictor")
+
+// Root cause analysis
+Task("Analyze test failure", `
+  Investigate recurring failure in AuthService tests:
+  - Collect failure history (last 30 days)
+  - Identify common patterns
+  - Trace to potential root causes
+  - Suggest fixes using 5-whys analysis
+`, "v3-qe-root-cause-analyzer")
+```
+
+## Prediction Models
+
+### 1. Change-Based Prediction
+
+```typescript
+await defectPredictor.predictFromChanges({
+  changes: prChanges,
+  factors: {
+    codeChurn: { weight: 0.2 },
+    complexity: { weight: 0.25 },
+    authorExperience: { weight: 0.15 },
+    fileHistory: { weight: 0.2 },
+    testCoverage: { weight: 0.2 }
+  },
+  threshold: {
+    high: 0.7,
+    medium: 0.4,
+    low: 0.2
+  }
+});
+```
+
+### 2. Pattern Learning
+
+```typescript
+await patternLearner.learnPatterns({
+  source: {
+    defects: 'jira:project=MYAPP&type=bug',
+    commits: 'git:last-6-months',
+    tests: 'test-results:last-1000-runs'
+  },
+  patterns: [
+    'code-smell-to-defect',
+    'change-coupling',
+    'test-gap-correlation',
+    'complexity-defect-density'
+  ],
+  output: {
+    rules: true,
+    visualizations: true,
+    recommendations: true
+  }
+});
+```
+
+### 3. Root Cause Analysis
+
+```typescript
+await rootCauseAnalyzer.analyze({
+  failure: testFailure,
+  methods: [
+    'five-whys',
+    'fishbone-diagram',
+    'fault-tree',
+    'change-impact'
+  ],
+  context: {
+    recentChanges: true,
+    environmentDiff: true,
+    dependencyChanges: true,
+    similarFailures: true
+  }
+});
+```
+
+## Defect Prediction Report
+
+```typescript
+interface DefectPrediction {
+  file: string;
+  riskScore: number;  // 0-1
+  riskLevel: 'critical' | 'high' | 'medium' | 'low';
+  factors: {
+    name: string;
+    contribution: number;
+    details: string;
+  }[];
+  historicalDefects: {
+    count: number;
+    recent: Defect[];
+    patterns: string[];
+  };
+  recommendations: {
+    action: string;
+    priority: string;
+    expectedRiskReduction: number;
+  }[];
+}
+```
+
+## Pattern Categories
+
+| Pattern | Detection | Prevention |
+|---------|-----------|------------|
+| Null pointer | Static analysis | Null checks, Optional |
+| Race condition | Concurrency analysis | Locks, atomic ops |
+| Memory leak | Heap analysis | Resource cleanup |
+| Off-by-one | Boundary analysis | Loop invariants |
+| Injection | Taint analysis | Input validation |
+
+## Root Cause Templates
+
+```yaml
+root_cause_analysis:
+  five_whys:
+    max_depth: 5
+    prompt_template: "Why did {effect} happen?"
+
+  fishbone:
+    categories:
+      - people
+      - process
+      - tools
+      - environment
+      - materials
+      - measurement
+
+  fault_tree:
+    top_event: "Test Failure"
+    gate_types: [AND, OR, NOT]
+    basic_events: true
+```
+
+## Integration with Issue Tracking
+
+```typescript
+await defectIntelligence.syncWithTracker({
+  source: 'jira',
+  project: 'MYAPP',
+  sync: {
+    defectData: 'bidirectional',
+    predictions: 'create-tasks',
+    patterns: 'update-labels'
+  },
+  automation: {
+    flagHighRisk: true,
+    suggestAssignee: true,
+    linkRelated: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-defect-predictor, v3-qe-pattern-learner, v3-qe-root-cause-analyzer
+**Coordinator**: v3-qe-defect-intelligence-coordinator
+**Related Skills**: v3-qe-coverage-analysis, v3-qe-quality-assessment