agentic-qe 3.8.1 → 3.8.3

package/.opencode/skills/qe-test-reporting-analytics.yaml

@@ -0,0 +1,45 @@
+name: qe-test-reporting-analytics
+description: "Advanced test reporting, quality dashboards, predictive analytics, trend analysis, and executive reporting for QE metrics. Use when communicating quality status, tracking trends, or making data-driven decisions."
+minModelTier: tier3-best
+tags: ["reporting", "analytics", "dashboards", "metrics", "trends", "predictive", "qe", "quality-engineering"]
+steps:
+  - name: essential-metrics
+    description: "Essential Metrics"
+    tools: ["bash", "read"]
+    prompt: |
+      Essential Metrics
+  - name: trend-indicators
+    description: "Trend Indicators"
+    tools: ["bash", "read"]
+    prompt: |
+      Trend Indicators
+  - name: report-types
+    description: "Report Types"
+    tools: ["bash", "read"]
+    prompt: |
+      Report Types
+  - name: real-time-dashboard
+    description: "Real-Time Dashboard"
+    tools: ["bash", "read"]
+    prompt: |
+      Real-Time Dashboard
+  - name: sprint-summary
+    description: "Sprint Summary"
+    tools: ["bash", "read"]
+    prompt: |
+      Sprint Summary
+  - name: sprint-47-quality-summary
+    description: "Sprint 47 Quality Summary"
+    tools: ["bash", "read"]
+    prompt: |
+      Sprint 47 Quality Summary
+  - name: metrics
+    description: "Metrics"
+    tools: ["bash", "read"]
+    prompt: |
+      Metrics
+  - name: highlights
+    description: "- ✅ Zero escaped defects - ⚠️ E2E suite now 45min (target: 30min)"
+    tools: ["bash", "read"]
+    prompt: |
+      - ✅ Zero escaped defects - ⚠️ E2E suite now 45min (target: 30min)

package/.opencode/skills/qe-testability-scoring.yaml

@@ -0,0 +1,45 @@
+name: qe-testability-scoring
+description: "AI-powered testability assessment using 10 principles of intrinsic testability with Playwright and optional Vibium integration. Evaluates web applications against Observability, Controllability, Algorithmic Simplicity, Transparency, Stability, Explainability, Unbugginess, Smallness, Decomposability,"
+minModelTier: tier3-best
+tags: ["testability", "scoring", "playwright", "vibium", "assessment", "10-principles", "intrinsic-testability", "james-bach", "michael-bolton", "qe", "quality-engineering", "testing-methodologies"]
+steps:
+  - name: running-assessments
+    description: "Running Assessments"
+    tools: ["bash", "read"]
+    prompt: |
+      Running Assessments
+  - name: principle-details
+    description: "Principle Details"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Principle Details
+  - name: assessment-workflow
+    description: "Assessment Workflow"
+    tools: ["bash", "read"]
+    prompt: |
+      Assessment Workflow
+  - name: output-files
+    description: "Output Files"
+    tools: ["bash", "read"]
+    prompt: |
+      Output Files
+  - name: integration-examples
+    description: "Integration Examples"
+    tools: ["bash", "read"]
+    prompt: |
+      Integration Examples
+  - name: cicd-integration
+    description: "CI/CD Integration"
+    tools: ["bash", "read"]
+    prompt: |
+      CI/CD Integration
+  - name: qx-partner-integration
+    description: "QX Partner Integration"
+    tools: ["bash", "read"]
+    prompt: |
+      QX Partner Integration
+  - name: programmatic-usage
+    description: "Programmatic Usage"
+    tools: ["bash", "read"]
+    prompt: |
+      Programmatic Usage

package/.opencode/skills/qe-verification-quality.yaml

@@ -0,0 +1,45 @@
+name: qe-verification-quality
+description: "Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability."
+minModelTier: tier2-good
+tags: ["verification", "truth-scoring", "quality", "rollback", "metrics", "ci-cd", "qe", "quality-engineering", "quality-assurance"]
+steps:
+  - name: what-this-skill-does
+    description: "This skill provides a comprehensive verification and quality assurance system that ensures code quality and correctness through:"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      This skill provides a comprehensive verification and quality assurance system that ensures code quality and correctness through:
+  - name: complete-guide
+    description: "Complete Guide"
+    tools: ["bash", "read"]
+    prompt: |
+      Complete Guide
+  - name: truth-scoring-system
+    description: "Truth Scoring System"
+    tools: ["bash", "read", "grep"]
+    prompt: |
+      Truth Scoring System
+  - name: verification-checks
+    description: "Verification Checks"
+    tools: ["bash", "read", "edit", "mcp:agentic-qe:*"]
+    prompt: |
+      Verification Checks
+  - name: automatic-rollback
+    description: "Automatic Rollback"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Automatic Rollback
+  - name: verification-reports
+    description: "Verification Reports"
+    tools: ["bash", "read"]
+    prompt: |
+      Verification Reports
+  - name: interactive-dashboard
+    description: "Interactive Dashboard"
+    tools: ["bash", "read"]
+    prompt: |
+      Interactive Dashboard
+  - name: configuration
+    description: "Configuration"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Configuration

package/.opencode/skills/qe-visual-accessibility.yaml

@@ -0,0 +1,45 @@
+name: qe-visual-accessibility
+description: "Visual regression testing, responsive design validation, and WCAG accessibility compliance testing."
+minModelTier: tier3-best
+tags: ["qe", "quality-engineering"]
+steps:
+  - name: agent-workflow
+    description: "Agent Workflow"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Agent Workflow
+  - name: visual-testing-operations
+    description: "Visual Testing Operations"
+    tools: ["bash", "read"]
+    prompt: |
+      Visual Testing Operations
+  - name: 1-visual-regression
+    description: "1. Visual Regression"
+    tools: ["bash", "read"]
+    prompt: |
+      1. Visual Regression
+  - name: 2-responsive-testing
+    description: "2. Responsive Testing"
+    tools: ["bash", "read"]
+    prompt: |
+      2. Responsive Testing
+  - name: 3-accessibility-audit
+    description: "3. Accessibility Audit"
+    tools: ["bash", "read"]
+    prompt: |
+      3. Accessibility Audit
+  - name: 4-cross-browser-testing
+    description: "4. Cross-Browser Testing"
+    tools: ["bash", "read"]
+    prompt: |
+      4. Cross-Browser Testing
+  - name: wcag-22-checklist
+    description: "WCAG 2.2 Checklist"
+    tools: ["bash", "read"]
+    prompt: |
+      WCAG 2.2 Checklist
+  - name: visual-test-report
+    description: "Visual Test Report"
+    tools: ["bash", "read"]
+    prompt: |
+      Visual Test Report

package/.opencode/skills/qe-visual-testing-advanced.yaml

@@ -0,0 +1,40 @@
+name: qe-visual-testing-advanced
+description: "Advanced visual regression testing with pixel-perfect comparison, AI-powered diff analysis, responsive design validation, and cross-browser visual consistency. Use when detecting UI regressions, validating designs, or ensuring visual consistency."
+minModelTier: tier3-best
+tags: ["visual", "regression", "screenshot", "pixel-diff", "percy", "playwright", "responsive", "qe", "quality-engineering", "specialized-testing"]
+steps:
+  - name: visual-bug-types
+    description: "Visual Bug Types"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Visual Bug Types
+  - name: comparison-algorithms
+    description: "Comparison Algorithms"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Comparison Algorithms
+  - name: visual-regression-with-playwright
+    description: "Visual Regression with Playwright"
+    tools: ["bash", "read"]
+    prompt: |
+      Visual Regression with Playwright
+  - name: handling-dynamic-content
+    description: "Handling Dynamic Content"
+    tools: ["bash", "read"]
+    prompt: |
+      Handling Dynamic Content
+  - name: ai-powered-visual-testing-percy
+    description: "AI-Powered Visual Testing (Percy)"
+    tools: ["bash", "read"]
+    prompt: |
+      AI-Powered Visual Testing (Percy)
+  - name: playwright-configuration
+    description: "Playwright Configuration"
+    tools: ["bash", "read"]
+    prompt: |
+      Playwright Configuration
+  - name: agent-driven-visual-testing
+    description: "Agent-Driven Visual Testing"
+    tools: ["bash", "read"]
+    prompt: |
+      Agent-Driven Visual Testing

package/.opencode/skills/qe-wms-testing-patterns.yaml

@@ -0,0 +1,45 @@
+name: qe-wms-testing-patterns
+description: "Warehouse Management System testing patterns for inventory operations, pick/pack/ship workflows, wave management, EDI X12/EDIFACT compliance, RF/barcode scanning, and WMS-ERP integration. Use when testing WMS platforms (Blue Yonder, Manhattan, SAP EWM)."
+minModelTier: tier3-best
+tags: ["wms", "warehouse", "inventory", "edi", "pick-pack-ship", "blue-yonder", "manhattan", "sap-ewm", "rf-scanning", "qe", "quality-engineering", "enterprise-integration"]
+steps:
+  - name: testing-levels
+    description: "Testing Levels"
+    tools: ["bash", "read"]
+    prompt: |
+      Testing Levels
+  - name: critical-test-scenarios
+    description: "Critical Test Scenarios"
+    tools: ["bash", "read"]
+    prompt: |
+      Critical Test Scenarios
+  - name: inventory-transaction-testing
+    description: "Inventory Transaction Testing"
+    tools: ["bash", "read"]
+    prompt: |
+      Inventory Transaction Testing
+  - name: receipt-and-putaway
+    description: "Receipt and Putaway"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Receipt and Putaway
+  - name: cycle-count-and-adjustments
+    description: "Cycle Count and Adjustments"
+    tools: ["bash", "read"]
+    prompt: |
+      Cycle Count and Adjustments
+  - name: pickpackship-workflow-testing
+    description: "Pick/Pack/Ship Workflow Testing"
+    tools: ["bash", "read"]
+    prompt: |
+      Pick/Pack/Ship Workflow Testing
+  - name: wave-management
+    description: "Wave Management"
+    tools: ["bash", "read"]
+    prompt: |
+      Wave Management
+  - name: allocation-logic
+    description: "Allocation Logic"
+    tools: ["bash", "read"]
+    prompt: |
+      Allocation Logic

package/.opencode/skills/qe-xp-practices.yaml

@@ -0,0 +1,45 @@
+name: qe-xp-practices
+description: "Apply XP practices including pair programming, ensemble programming, continuous integration, and sustainable pace. Use when implementing agile development practices, improving team collaboration, or adopting technical excellence practices."
+minModelTier: tier1-any
+tags: ["xp", "agile", "pair-programming", "tdd", "continuous-integration", "collaboration", "qe", "quality-engineering", "methodology"]
+steps:
+  - name: the-five-xp-values
+    description: "The Five XP Values"
+    tools: ["bash", "read"]
+    prompt: |
+      The Five XP Values
+  - name: core-practices
+    description: "Core Practices"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      Core Practices
+  - name: pair-programming
+    description: "Pair Programming"
+    tools: ["bash", "read"]
+    prompt: |
+      Pair Programming
+  - name: when-to-pair
+    description: "When to Pair"
+    tools: ["bash", "read", "grep"]
+    prompt: |
+      When to Pair
+  - name: pairing-dos-and-donts
+    description: "**Do:** - ✅ Switch roles every 20-30 min - ✅ Take breaks together - ✅ Think out loud - ✅ Ask questions - ✅ Keep sessions 2-4 hours max"
+    tools: ["bash", "read"]
+    prompt: |
+      **Do:** - ✅ Switch roles every 20-30 min - ✅ Take breaks together - ✅ Think out loud - ✅ Ask questions - ✅ Keep sessions 2-4 hours max
+  - name: ensemble-mob-programming
+    description: "**Setup:** 3+ developers, one screen, rotating driver"
+    tools: ["bash", "read"]
+    prompt: |
+      **Setup:** 3+ developers, one screen, rotating driver
+  - name: continuous-integration
+    description: "**CI Workflow:**"
+    tools: ["bash", "read", "edit"]
+    prompt: |
+      **CI Workflow:**
+  - name: four-rules-of-simple-design
+    description: "(In priority order) 1. **Passes all tests** - Works correctly 2. **Reveals intention** - Clear, expressive code 3. **No duplication** - DRY principle 4. **Fewest elements** - No speculative code"
+    tools: ["bash", "read"]
+    prompt: |
+      (In priority order) 1. **Passes all tests** - Works correctly 2. **Reveals intention** - Clear, expressive code 3. **No duplication** - DRY principle 4. **Fewest elements** - No speculative code

package/.opencode/tools/qe-defect-scan.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+
+export default {
+  name: 'qe-defect-scan',
+  description: 'Run defect prediction and code indexing for comprehensive defect intelligence analysis',
+  parameters: z.object({
+    target: z.string().describe('Target path to scan for potential defects'),
+    indexCode: z.boolean().default(true).describe('Index code into knowledge graph before prediction'),
+    includePatterns: z.boolean().default(true).describe('Query memory for known defect patterns'),
+  }),
+  execute: async (
+    params: { target: string; indexCode: boolean; includePatterns: boolean },
+    ctx: any,
+  ) => {
+    const startTime = Date.now();
+    const results: Record<string, any> = {};
+
+    // Step 1: Index code for knowledge graph (if requested)
+    if (params.indexCode) {
+      try {
+        results.index = await ctx.callTool('mcp:agentic-qe:code_index', {
+          target: params.target,
+        });
+      } catch (err: any) {
+        results.index = { error: `Code indexing failed: ${err.message}` };
+      }
+    }
+
+    // Step 2: Run defect prediction
+    try {
+      results.prediction = await ctx.callTool('mcp:agentic-qe:defect_predict', {
+        target: params.target,
+      });
+    } catch (err: any) {
+      return {
+        error: `Defect prediction failed: ${err.message}`,
+        phase: 'predict',
+      };
+    }
+
+    // Step 3: Query memory for known patterns (if requested)
+    if (params.includePatterns) {
+      try {
+        results.knownPatterns = await ctx.callTool('mcp:agentic-qe:memory_query', {
+          pattern: 'defect-patterns/*',
+          namespace: 'qe-defects',
+        });
+      } catch (err: any) {
+        results.knownPatterns = { error: `Pattern query failed: ${err.message}` };
+      }
+    }
+
+    const elapsed = Date.now() - startTime;
+
+    // Store scan results for learning
+    try {
+      await ctx.callTool('mcp:agentic-qe:memory_store', {
+        key: `defect-scan/${params.target}/${Date.now()}`,
+        namespace: 'qe-defects',
+        value: {
+          target: params.target,
+          prediction: results.prediction,
+          timestamp: new Date().toISOString(),
+        },
+      });
+    } catch {
+      // Non-critical
+    }
+
+    return {
+      target: params.target,
+      codeIndex: results.index,
+      prediction: results.prediction,
+      knownPatterns: results.knownPatterns,
+      elapsedMs: elapsed,
+      summary: `Defect scan completed for ${params.target} in ${elapsed}ms.`,
+    };
+  },
+};

package/.opencode/tools/qe-fleet-status.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+
+export default {
+  name: 'qe-fleet-status',
+  description: 'Get comprehensive fleet status including agent health, task progress, and performance metrics',
+  parameters: z.object({
+    verbose: z.boolean().default(false).describe('Include detailed agent-level information'),
+    includeMetrics: z.boolean().default(true).describe('Include performance metrics for all agents'),
+    domain: z.string().optional().describe('Filter to a specific domain (e.g., "testing", "security")'),
+  }),
+  execute: async (
+    params: { verbose: boolean; includeMetrics: boolean; domain?: string },
+    ctx: any,
+  ) => {
+    const startTime = Date.now();
+    const results: Record<string, any> = {};
+
+    // Step 1: Get fleet status
+    try {
+      results.fleet = await ctx.callTool('mcp:agentic-qe:fleet_status', {
+        verbose: params.verbose,
+      });
+    } catch (err: any) {
+      results.fleet = { error: `Fleet status failed: ${err.message}` };
+    }
+
+    // Step 2: Get agent metrics (if requested)
+    if (params.includeMetrics) {
+      try {
+        results.metrics = await ctx.callTool('mcp:agentic-qe:agent_metrics', {});
+      } catch (err: any) {
+        results.metrics = { error: `Agent metrics failed: ${err.message}` };
+      }
+    }
+
+    // Step 3: Get fleet health
+    try {
+      if (params.domain) {
+        results.health = await ctx.callTool('mcp:agentic-qe:fleet_health', {
+          domain: params.domain,
+        });
+      } else {
+        results.health = await ctx.callTool('mcp:agentic-qe:fleet_health', {});
+      }
+    } catch (err: any) {
+      results.health = { error: `Health check failed: ${err.message}` };
+    }
+
+    const elapsed = Date.now() - startTime;
+
+    return {
+      fleet: results.fleet,
+      metrics: results.metrics,
+      health: results.health,
+      elapsedMs: elapsed,
+      summary: `Fleet status dashboard retrieved in ${elapsed}ms.`,
+    };
+  },
+};

package/.opencode/tools/qe-full-audit.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+
+export default {
+  name: 'qe-full-audit',
+  description: 'Run comprehensive QE audit: quality assessment + security scan + coverage analysis in sequence',
+  parameters: z.object({
+    target: z.string().describe('Target path to audit (e.g., "src/" or "src/services/")'),
+    includeTests: z.boolean().default(true).describe('Include test files in the audit scope'),
+    runGate: z.boolean().default(true).describe('Run quality gate evaluation to determine pass/fail'),
+    dast: z.boolean().default(false).describe('Include DAST (dynamic) scanning in addition to SAST'),
+  }),
+  execute: async (
+    params: { target: string; includeTests: boolean; runGate: boolean; dast: boolean },
+    ctx: any,
+  ) => {
+    const startTime = Date.now();
+    const results: Record<string, any> = {};
+    const errors: string[] = [];
+
+    // Step 1: Quality assessment
+    try {
+      results.quality = await ctx.callTool('mcp:agentic-qe:quality_assess', {
+        runGate: params.runGate,
+      });
+    } catch (err: any) {
+      errors.push(`Quality assessment failed: ${err.message}`);
+    }
+
+    // Step 2: Security scan (SAST + optional DAST)
+    try {
+      results.security = await ctx.callTool('mcp:agentic-qe:security_scan_comprehensive', {
+        target: params.target,
+        sast: true,
+        dast: params.dast,
+      });
+    } catch (err: any) {
+      errors.push(`Security scan failed: ${err.message}`);
+    }
+
+    // Step 3: Coverage analysis with gap detection
+    try {
+      results.coverage = await ctx.callTool('mcp:agentic-qe:coverage_analyze_sublinear', {
+        target: params.target,
+        detectGaps: true,
+      });
+    } catch (err: any) {
+      errors.push(`Coverage analysis failed: ${err.message}`);
+    }
+
+    const elapsed = Date.now() - startTime;
+
+    // Store audit results in memory for tracking
+    try {
+      await ctx.callTool('mcp:agentic-qe:memory_store', {
+        key: `audit/${params.target}/${Date.now()}`,
+        namespace: 'qe-audits',
+        value: {
+          target: params.target,
+          timestamp: new Date().toISOString(),
+          quality: results.quality ?? null,
+          security: results.security ?? null,
+          coverage: results.coverage ?? null,
+          errors,
+          elapsedMs: elapsed,
+        },
+      });
+    } catch {
+      // Non-critical: memory store failure should not fail the audit
+    }
+
+    return {
+      target: params.target,
+      quality: results.quality ?? { error: 'Assessment failed' },
+      security: results.security ?? { error: 'Scan failed' },
+      coverage: results.coverage ?? { error: 'Analysis failed' },
+      errors: errors.length > 0 ? errors : undefined,
+      elapsedMs: elapsed,
+      summary: `Audit completed in ${elapsed}ms. ${errors.length} errors encountered.`,
+    };
+  },
+};

package/.opencode/tools/qe-learning-report.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+
+export default {
+  name: 'qe-learning-report',
+  description: 'Query AQE memory for learned patterns and generate a comprehensive learning summary report',
+  parameters: z.object({
+    namespace: z.string().default('default').describe('Memory namespace to query'),
+    pattern: z.string().default('*').describe('Key pattern to match (glob syntax)'),
+    includeSemanticSearch: z.boolean().default(false).describe('Use HNSW semantic search'),
+    semanticQuery: z.string().optional().describe('Natural language query for semantic search'),
+    limit: z.number().default(50).describe('Maximum number of entries to retrieve'),
+  }),
+  execute: async (
+    params: {
+      namespace: string;
+      pattern: string;
+      includeSemanticSearch: boolean;
+      semanticQuery?: string;
+      limit: number;
+    },
+    ctx: any,
+  ) => {
+    const startTime = Date.now();
+    const results: Record<string, any> = {};
+
+    // Step 1: Pattern-based memory query
+    try {
+      results.patterns = await ctx.callTool('mcp:agentic-qe:memory_query', {
+        pattern: params.pattern,
+        namespace: params.namespace,
+      });
+    } catch (err: any) {
+      results.patterns = { error: `Pattern query failed: ${err.message}` };
+    }
+
+    // Step 2: Semantic search (if requested)
+    if (params.includeSemanticSearch && params.semanticQuery) {
+      try {
+        results.semantic = await ctx.callTool('mcp:agentic-qe:memory_query', {
+          pattern: params.semanticQuery,
+          namespace: params.namespace,
+          semantic: true,
+        });
+      } catch (err: any) {
+        results.semantic = { error: `Semantic search failed: ${err.message}` };
+      }
+    }
+
+    // Step 3: Get memory usage stats
+    try {
+      results.usage = await ctx.callTool('mcp:agentic-qe:memory_usage', {});
+    } catch (err: any) {
+      results.usage = { error: `Memory usage query failed: ${err.message}` };
+    }
+
+    const elapsed = Date.now() - startTime;
+
+    // Compile summary
+    const patternCount = Array.isArray(results.patterns?.data)
+      ? results.patterns.data.length
+      : 0;
+    const semanticCount = Array.isArray(results.semantic?.data)
+      ? results.semantic.data.length
+      : 0;
+
+    return {
+      patterns: results.patterns,
+      semanticResults: results.semantic,
+      memoryUsage: results.usage,
+      elapsedMs: elapsed,
+      summary: `Learning report: ${patternCount} pattern matches, ${semanticCount} semantic matches. Generated in ${elapsed}ms.`,
+    };
+  },
+};