@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/assets/skills/v3-qe-learning-optimization/SKILL.md

@@ -0,0 +1,238 @@
+---
+name: "V3 QE Learning Optimization"
+description: "Transfer learning, metrics optimization, and continuous improvement for AI-powered QE agents."
+---
+
+# V3 QE Learning Optimization
+
+## Purpose
+
+Guide the use of v3's learning optimization capabilities including transfer learning between agents, hyperparameter tuning, A/B testing, and continuous performance improvement.
+
+## Activation
+
+- When optimizing agent performance
+- When transferring knowledge between agents
+- When tuning learning parameters
+- When running A/B tests
+- When analyzing learning metrics
+
+## Quick Start
+
+```bash
+# Transfer knowledge between agents
+aqe-v3 learn transfer --from jest-generator --to vitest-generator
+
+# Tune hyperparameters
+aqe-v3 learn tune --agent defect-predictor --metric accuracy
+
+# Run A/B test
+aqe-v3 learn ab-test --hypothesis "new-algorithm" --duration 7d
+
+# View learning metrics
+aqe-v3 learn metrics --agent test-generator --period 30d
+```
+
+## Agent Workflow
+
+```typescript
+// Transfer learning
+Task("Transfer test patterns", `
+  Transfer learned patterns from Jest test generator to Vitest:
+  - Map framework-specific syntax
+  - Adapt assertion styles
+  - Preserve test structure patterns
+  - Validate transfer accuracy
+`, "v3-qe-transfer-specialist")
+
+// Metrics optimization
+Task("Optimize prediction accuracy", `
+  Tune defect-predictor agent:
+  - Analyze current performance metrics
+  - Run Bayesian hyperparameter search
+  - Validate improvements on holdout set
+  - Deploy if accuracy improves >5%
+`, "v3-qe-metrics-optimizer")
+```
+
+## Learning Operations
+
+### 1. Transfer Learning
+
+```typescript
+await transferSpecialist.transfer({
+  source: {
+    agent: 'v3-qe-jest-generator',
+    knowledge: ['patterns', 'heuristics', 'optimizations']
+  },
+  target: {
+    agent: 'v3-qe-vitest-generator',
+    adaptations: ['framework-syntax', 'api-differences']
+  },
+  strategy: 'fine-tuning',
+  validation: {
+    testSet: 'validation-samples',
+    minAccuracy: 0.9
+  }
+});
+```
+
+### 2. Hyperparameter Tuning
+
+```typescript
+await metricsOptimizer.tune({
+  agent: 'defect-predictor',
+  parameters: {
+    learningRate: { min: 0.001, max: 0.1, type: 'log' },
+    batchSize: { values: [16, 32, 64, 128] },
+    patternThreshold: { min: 0.5, max: 0.95 }
+  },
+  optimization: {
+    method: 'bayesian',
+    objective: 'accuracy',
+    trials: 50,
+    parallelism: 4
+  }
+});
+```
+
+### 3. A/B Testing
+
+```typescript
+await metricsOptimizer.abTest({
+  hypothesis: 'ML pattern matching improves test quality',
+  variants: {
+    control: { algorithm: 'rule-based' },
+    treatment: { algorithm: 'ml-enhanced' }
+  },
+  metrics: ['test-quality-score', 'generation-time'],
+  traffic: {
+    split: 50,
+    minSampleSize: 1000
+  },
+  duration: '7d',
+  significance: 0.05
+});
+```
+
+### 4. Feedback Loop
+
+```typescript
+await metricsOptimizer.feedbackLoop({
+  agent: 'test-generator',
+  feedback: {
+    sources: ['user-corrections', 'test-results', 'code-reviews'],
+    aggregation: 'weighted',
+    frequency: 'real-time'
+  },
+  learning: {
+    strategy: 'incremental',
+    validationSplit: 0.2,
+    earlyStoppingPatience: 5
+  }
+});
+```
+
+## Learning Metrics Dashboard
+
+```typescript
+interface LearningDashboard {
+  agent: string;
+  period: DateRange;
+  performance: {
+    current: MetricValues;
+    trend: 'improving' | 'stable' | 'declining';
+    percentile: number;
+  };
+  learning: {
+    samplesProcessed: number;
+    patternsLearned: number;
+    improvementRate: number;
+  };
+  experiments: {
+    active: Experiment[];
+    completed: ExperimentResult[];
+  };
+  recommendations: {
+    action: string;
+    expectedImpact: number;
+    confidence: number;
+  }[];
+}
+```
+
+## Cross-Framework Transfer
+
+```yaml
+transfer_mappings:
+  jest_to_vitest:
+    syntax:
+      "describe": "describe"
+      "it": "it"
+      "expect": "expect"
+      "jest.mock": "vi.mock"
+      "jest.fn": "vi.fn"
+    patterns:
+      - mock-module
+      - async-testing
+      - snapshot-testing
+
+  mocha_to_jest:
+    syntax:
+      "describe": "describe"
+      "it": "it"
+      "chai.expect": "expect"
+      "sinon.stub": "jest.fn"
+    adaptations:
+      - assertion-style
+      - hook-naming
+```
+
+## Continuous Improvement
+
+```typescript
+await learningOptimizer.continuousImprovement({
+  agents: ['test-generator', 'coverage-analyzer', 'defect-predictor'],
+  schedule: {
+    metricCollection: 'hourly',
+    tuning: 'weekly',
+    majorUpdates: 'monthly'
+  },
+  thresholds: {
+    degradationAlert: 5,  // percent
+    improvementTarget: 2,  // percent per week
+  },
+  automation: {
+    autoTune: true,
+    autoRollback: true,
+    requireApproval: ['major-changes']
+  }
+});
+```
+
+## Pattern Learning
+
+```typescript
+await patternLearner.learn({
+  sources: {
+    codeExamples: 'examples/**/*.ts',
+    testExamples: 'tests/**/*.test.ts',
+    userFeedback: 'feedback/*.json'
+  },
+  extraction: {
+    syntacticPatterns: true,
+    semanticPatterns: true,
+    contextualPatterns: true
+  },
+  storage: {
+    vectorDB: 'agentdb',
+    versioning: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-transfer-specialist, v3-qe-metrics-optimizer, v3-qe-pattern-learner
+**Coordinator**: v3-qe-learning-coordinator
+**Related Skills**: v3-qe-test-generation, v3-qe-defect-intelligence

package/assets/skills/v3-qe-quality-assessment/SKILL.md

@@ -0,0 +1,213 @@
+---
+name: "V3 QE Quality Assessment"
+description: "Comprehensive quality gates, metrics analysis, and deployment readiness assessment for continuous quality assurance."
+---
+
+# V3 QE Quality Assessment
+
+## Purpose
+
+Guide the use of v3's quality assessment capabilities including automated quality gates, metrics aggregation, trend analysis, and deployment readiness evaluation.
+
+## Activation
+
+- When evaluating code quality
+- When setting up quality gates
+- When assessing deployment readiness
+- When tracking quality metrics
+- When generating quality reports
+
+## Quick Start
+
+```bash
+# Run quality assessment
+aqe-v3 quality assess --scope src/ --gates all
+
+# Check deployment readiness
+aqe-v3 quality deploy-ready --environment production
+
+# Generate quality report
+aqe-v3 quality report --format dashboard --period 30d
+
+# Compare quality between releases
+aqe-v3 quality compare --from v1.0 --to v2.0
+```
+
+## Agent Workflow
+
+```typescript
+// Comprehensive quality assessment
+Task("Assess code quality", `
+  Evaluate quality for src/:
+  - Code complexity (cyclomatic, cognitive)
+  - Test coverage and mutation score
+  - Security vulnerabilities
+  - Code smells and technical debt
+  - Documentation coverage
+  Generate quality score and recommendations.
+`, "v3-qe-quality-analyzer")
+
+// Deployment readiness check
+Task("Check deployment readiness", `
+  Evaluate if release v2.1.0 is ready for production:
+  - All tests passing
+  - Coverage thresholds met
+  - No critical vulnerabilities
+  - Performance benchmarks passed
+  - Documentation updated
+  Provide go/no-go recommendation.
+`, "v3-qe-deployment-advisor")
+```
+
+## Quality Dimensions
+
+### 1. Code Quality Metrics
+
+```typescript
+await qualityAnalyzer.assessCode({
+  scope: 'src/**/*.ts',
+  metrics: {
+    complexity: {
+      cyclomatic: { max: 15, warn: 10 },
+      cognitive: { max: 20, warn: 15 }
+    },
+    maintainability: {
+      index: { min: 65 },
+      duplication: { max: 3 }  // percent
+    },
+    documentation: {
+      publicAPIs: { min: 80 },
+      complexity: { min: 70 }
+    }
+  }
+});
+```
+
+### 2. Quality Gates
+
+```typescript
+await qualityGate.evaluate({
+  gates: {
+    coverage: { min: 80, blocking: true },
+    complexity: { max: 15, blocking: false },
+    vulnerabilities: { critical: 0, high: 0, blocking: true },
+    duplications: { max: 3, blocking: false },
+    techDebt: { maxRatio: 5, blocking: false }
+  },
+  action: {
+    onPass: 'proceed',
+    onFail: 'block-merge',
+    onWarn: 'notify'
+  }
+});
+```
+
+### 3. Deployment Readiness
+
+```typescript
+await deploymentAdvisor.assess({
+  release: 'v2.1.0',
+  criteria: {
+    testing: {
+      unitTests: 'all-pass',
+      integrationTests: 'all-pass',
+      e2eTests: 'critical-pass',
+      performanceTests: 'baseline-met'
+    },
+    quality: {
+      coverage: 80,
+      noNewVulnerabilities: true,
+      noRegressions: true
+    },
+    documentation: {
+      changelog: true,
+      apiDocs: true,
+      releaseNotes: true
+    }
+  }
+});
+```
+
+## Quality Score Calculation
+
+```yaml
+quality_score:
+  components:
+    test_coverage:
+      weight: 0.25
+      metrics: [statement, branch, function]
+
+    code_quality:
+      weight: 0.20
+      metrics: [complexity, maintainability, duplication]
+
+    security:
+      weight: 0.25
+      metrics: [vulnerabilities, dependencies]
+
+    reliability:
+      weight: 0.20
+      metrics: [bug_density, flaky_tests, error_rate]
+
+    documentation:
+      weight: 0.10
+      metrics: [api_coverage, readme, changelog]
+
+  scoring:
+    A: 90-100
+    B: 80-89
+    C: 70-79
+    D: 60-69
+    F: 0-59
+```
+
+## Quality Dashboard
+
+```typescript
+interface QualityDashboard {
+  overallScore: number;  // 0-100
+  grade: 'A' | 'B' | 'C' | 'D' | 'F';
+  dimensions: {
+    name: string;
+    score: number;
+    trend: 'improving' | 'stable' | 'declining';
+    issues: Issue[];
+  }[];
+  gates: {
+    name: string;
+    status: 'pass' | 'fail' | 'warn';
+    value: number;
+    threshold: number;
+  }[];
+  trends: {
+    period: string;
+    scores: number[];
+    alerts: Alert[];
+  };
+  recommendations: Recommendation[];
+}
+```
+
+## CI/CD Integration
+
+```yaml
+# Quality gate in pipeline
+quality_check:
+  stage: verify
+  script:
+    - aqe-v3 quality assess --gates all --output report.json
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+  artifacts:
+    reports:
+      quality: report.json
+  allow_failure:
+    exit_codes:
+      - 1  # Warnings only
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-quality-analyzer, v3-qe-deployment-advisor, v3-qe-metrics-collector
+**Coordinator**: v3-qe-quality-coordinator
+**Related Skills**: v3-qe-coverage-analysis, v3-qe-security-compliance

package/assets/skills/v3-qe-requirements-validation/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: "V3 QE Requirements Validation"
+description: "Requirements traceability, acceptance criteria validation, and BDD scenario management for complete requirements coverage."
+---
+
+# V3 QE Requirements Validation
+
+## Purpose
+
+Guide the use of v3's requirements validation capabilities including acceptance criteria parsing, requirements traceability, BDD scenario generation, and coverage gap identification.
+
+## Activation
+
+- When validating requirements
+- When tracing requirements to tests
+- When generating BDD scenarios
+- When assessing requirements coverage
+- When reviewing acceptance criteria
+
+## Quick Start
+
+```bash
+# Parse acceptance criteria
+aqe-v3 requirements parse --source jira --project MYAPP
+
+# Build traceability matrix
+aqe-v3 requirements trace --requirements reqs/ --tests tests/
+
+# Generate BDD scenarios
+aqe-v3 requirements bdd --story US-123 --output features/
+
+# Check requirements coverage
+aqe-v3 requirements coverage --sprint current
+```
+
+## Agent Workflow
+
+```typescript
+// Requirements validation
+Task("Validate acceptance criteria", `
+  Review acceptance criteria for sprint stories:
+  - Check SMART criteria (Specific, Measurable, Achievable, Relevant, Testable)
+  - Identify ambiguous requirements
+  - Flag missing edge cases
+  - Suggest improvements
+`, "v3-qe-acceptance-criteria")
+
+// Traceability matrix
+Task("Build traceability", `
+  Create requirements traceability matrix:
+  - Map user stories to test cases
+  - Identify untested requirements
+  - Find orphan tests (no linked requirement)
+  - Calculate coverage metrics
+`, "v3-qe-traceability-builder")
+```
+
+## Requirements Operations
+
+### 1. Acceptance Criteria Validation
+
+```typescript
+await acceptanceCriteria.validate({
+  source: {
+    type: 'jira',
+    project: 'MYAPP',
+    stories: 'sprint=current'
+  },
+  validation: {
+    specific: true,
+    measurable: true,
+    achievable: true,
+    relevant: true,
+    testable: true
+  },
+  output: {
+    score: true,
+    issues: true,
+    suggestions: true
+  }
+});
+```
+
+### 2. Traceability Matrix
+
+```typescript
+await traceabilityBuilder.build({
+  requirements: {
+    source: 'jira',
+    types: ['story', 'task', 'bug']
+  },
+  artifacts: {
+    tests: 'tests/**/*.test.ts',
+    code: 'src/**/*.ts',
+    documentation: 'docs/**/*.md'
+  },
+  output: {
+    matrix: true,
+    coverage: true,
+    gaps: true,
+    orphans: true
+  }
+});
+```
+
+### 3. BDD Scenario Generation
+
+```typescript
+await bddGenerator.generate({
+  requirements: userStory,
+  format: 'gherkin',
+  scenarios: {
+    happyPath: true,
+    edgeCases: true,
+    errorCases: true,
+    dataVariations: true
+  },
+  output: {
+    featureFile: true,
+    stepDefinitions: 'skeleton'
+  }
+});
+```
+
+### 4. Coverage Analysis
+
+```typescript
+await requirementsCoverage.analyze({
+  scope: 'sprint-23',
+  metrics: {
+    requirementsCovered: true,
+    testCasesCoverage: true,
+    automationCoverage: true,
+    riskAssessment: true
+  },
+  report: {
+    summary: true,
+    details: true,
+    recommendations: true
+  }
+});
+```
+
+## Traceability Matrix
+
+```typescript
+interface TraceabilityMatrix {
+  requirements: {
+    id: string;
+    title: string;
+    type: string;
+    priority: string;
+    status: string;
+    linkedTests: string[];
+    linkedCode: string[];
+    coverage: 'full' | 'partial' | 'none';
+  }[];
+  tests: {
+    id: string;
+    name: string;
+    type: 'unit' | 'integration' | 'e2e';
+    linkedRequirements: string[];
+    automated: boolean;
+  }[];
+  coverage: {
+    requirementsCovered: number;
+    requirementsPartial: number;
+    requirementsUncovered: number;
+    orphanTests: number;
+  };
+  gaps: {
+    requirement: string;
+    missingCoverage: string[];
+    risk: 'high' | 'medium' | 'low';
+  }[];
+}
+```
+
+## BDD Integration
+
+```gherkin
+# Generated feature file
+Feature: User Registration
+  As a new user
+  I want to create an account
+  So that I can access the platform
+
+  @happy-path
+  Scenario: Successful registration with valid details
+    Given I am on the registration page
+    When I enter valid email "user@example.com"
+    And I enter valid password "SecurePass123!"
+    And I click the register button
+    Then I should see a success message
+    And I should receive a confirmation email
+
+  @edge-case
+  Scenario: Registration with existing email
+    Given a user exists with email "existing@example.com"
+    When I try to register with email "existing@example.com"
+    Then I should see an error "Email already registered"
+```
+
+## Requirements Quality
+
+```yaml
+quality_checks:
+  acceptance_criteria:
+    has_given_when_then: preferred
+    is_testable: required
+    is_measurable: required
+    no_ambiguity: required
+
+  user_story:
+    follows_template: "As a <role>, I want <feature>, so that <benefit>"
+    has_acceptance_criteria: required
+    estimated: preferred
+
+  completeness:
+    edge_cases_identified: required
+    error_scenarios_covered: required
+    non_functional_considered: preferred
+```
+
+## Sprint Integration
+
+```typescript
+await requirementsValidator.sprintReview({
+  sprint: 'current',
+  checks: {
+    storiesComplete: true,
+    criteriaValidated: true,
+    testsLinked: true,
+    coverageAdequate: true
+  },
+  gates: {
+    minCoverage: 80,
+    maxUntested: 2,
+    requireDemo: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-acceptance-criteria, v3-qe-traceability-builder, v3-qe-bdd-specialist
+**Coordinator**: v3-qe-requirements-coordinator
+**Related Skills**: v3-qe-test-generation, v3-qe-quality-assessment