agentic-qe 1.0.0 → 1.0.2

package/.claude/agents/qe-test-generator.md

@@ -13,15 +13,8 @@ capabilities:
   - mutation-testing
   - performance-testing
   - api-testing
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Starting test generation'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-requirements'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/test-generation/results' --value '${TEST_RESULTS}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/test-files/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   frameworks: ["jest", "mocha", "cypress", "playwright", "vitest"]
@@ -76,18 +69,178 @@ Generate tests using AI-powered templates and patterns:
 - State transition testing
 - Error condition testing
 
-## Integration Points
+## Coordination Protocol
 
-### Memory Coordination
-```bash
-# Store test generation context
-npx claude-flow@alpha memory store --key "aqe/test-context/${MODULE}" --value "${CONTEXT}"
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+// Called automatically by BaseAgent
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Load test requirements from memory
+  const requirements = await this.memoryStore.retrieve('aqe/test-requirements', {
+    partition: 'coordination'
+  });
+
+  // Retrieve code analysis data
+  const codeAnalysis = await this.memoryStore.retrieve(`aqe/code-analysis/${data.assignment.task.metadata.module}`, {
+    partition: 'analysis'
+  });
+
+  // Verify environment for test generation
+  const verification = await this.hookManager.executePreTaskVerification({
+    task: 'test-generation',
+    context: {
+      requiredVars: ['NODE_ENV', 'TEST_FRAMEWORK'],
+      minMemoryMB: 512,
+      requiredModules: ['jest', '@types/jest', 'fast-check']
+    }
+  });
+
+  // Emit test generation starting event
+  this.eventBus.emit('test-generator:starting', {
+    agentId: this.agentId,
+    module: data.assignment.task.metadata.module,
+    framework: requirements?.framework || 'jest'
+  });
+
+  this.logger.info('Test generation starting', {
+    requirements,
+    verification: verification.passed
+  });
+}
+
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store test generation results in swarm memory
+  await this.memoryStore.store('aqe/test-generation/results', data.result, {
+    partition: 'agent_results',
+    ttl: 86400 // 24 hours
+  });
+
+  // Store generated test files
+  for (const testFile of data.result.generatedFiles) {
+    await this.memoryStore.store(`aqe/test-files/${testFile.name}`, testFile.content, {
+      partition: 'test_artifacts',
+      ttl: 604800 // 7 days
+    });
+  }
+
+  // Store coverage analysis
+  await this.memoryStore.store('aqe/coverage-analysis', {
+    timestamp: Date.now(),
+    coverage: data.result.coverage,
+    testsGenerated: data.result.testsGenerated,
+    framework: data.result.framework
+  }, {
+    partition: 'metrics',
+    ttl: 604800 // 7 days
+  });
+
+  // Emit completion event with test generation stats
+  this.eventBus.emit('test-generator:completed', {
+    agentId: this.agentId,
+    testsGenerated: data.result.testsGenerated,
+    coverage: data.result.coverage,
+    framework: data.result.framework
+  });
+
+  // Validate test generation results
+  const validation = await this.hookManager.executePostTaskValidation({
+    task: 'test-generation',
+    result: {
+      output: data.result,
+      coverage: data.result.coverage,
+      metrics: {
+        testsGenerated: data.result.testsGenerated,
+        executionTime: data.result.executionTime
+      }
+    }
+  });
+
+  this.logger.info('Test generation completed', {
+    testsGenerated: data.result.testsGenerated,
+    coverage: data.result.coverage,
+    validated: validation.passed
+  });
+}
+
+protected async onTaskError(data: { assignment: TaskAssignment; error: Error }): Promise<void> {
+  // Store error for fleet analysis
+  await this.memoryStore.store(`aqe/errors/${data.assignment.task.id}`, {
+    error: data.error.message,
+    timestamp: Date.now(),
+    agent: this.agentId,
+    taskType: 'test-generation',
+    module: data.assignment.task.metadata.module
+  }, {
+    partition: 'errors',
+    ttl: 604800 // 7 days
+  });
 
-# Retrieve coverage requirements
-npx claude-flow@alpha memory retrieve --key "aqe/coverage-requirements"
+  // Emit error event for fleet coordination
+  this.eventBus.emit('test-generator:error', {
+    agentId: this.agentId,
+    error: data.error.message,
+    taskId: data.assignment.task.id
+  });
 
-# Share test results with QE fleet
-npx claude-flow@alpha memory store --key "aqe/test-results/${SUITE}" --value "${RESULTS}"
+  this.logger.error('Test generation failed', {
+    error: data.error.message,
+    stack: data.error.stack
+  });
+}
+```
+
+**Advanced Verification (Optional):**
+```typescript
+// Use VerificationHookManager for comprehensive validation
+const hookManager = new VerificationHookManager(this.memoryStore);
+
+// Pre-task verification with environment checks
+const verification = await hookManager.executePreTaskVerification({
+  task: 'test-generation',
+  context: {
+    requiredVars: ['NODE_ENV', 'TEST_FRAMEWORK'],
+    minMemoryMB: 512,
+    requiredModules: ['jest', '@types/jest', 'fast-check', '@testing-library/react']
+  }
+});
+
+// Post-task validation with result verification
+const validation = await hookManager.executePostTaskValidation({
+  task: 'test-generation',
+  result: {
+    output: generatedTests,
+    coverage: 0.95,
+    metrics: {
+      testsGenerated: 50,
+      propertyTests: 10,
+      boundaryTests: 15,
+      integrationTests: 25
+    }
+  }
+});
+
+// Pre-edit verification before writing test files
+const editCheck = await hookManager.executePreEditVerification({
+  filePath: 'tests/generated/user.test.ts',
+  operation: 'write',
+  content: testFileContent
+});
+
+// Post-edit update after test file creation
+const editUpdate = await hookManager.executePostEditUpdate({
+  filePath: 'tests/generated/user.test.ts',
+  operation: 'write',
+  success: true
+});
+
+// Session finalization with test suite export
+const finalization = await hookManager.executeSessionEndFinalization({
+  sessionId: 'test-generation-v2.0.0',
+  exportMetrics: true,
+  exportArtifacts: true
+});
 ```
 
 ### Agent Collaboration
@@ -118,26 +271,16 @@ npx claude-flow@alpha memory store --key "aqe/test-results/${SUITE}" --value "${
 ## Coordination Protocol
 
 ### Swarm Integration
-```bash
-# Initialize test generation workflow
-npx claude-flow@alpha task orchestrate \
-  --task "Generate comprehensive test suite for ${MODULE}" \
-  --agents "qe-test-generator,qe-analyzer,qe-validator" \
-  --strategy "parallel"
-
-# Coordinate with neural training
-npx claude-flow@alpha neural train \
-  --pattern-type "optimization" \
-  --training-data "test-generation-patterns"
-```
 
-### Agent Spawning Protocol
-```bash
-# Spawn test generator with specific capabilities
-npx claude-flow@alpha agent spawn \
-  --type "test-generator" \
-  --capabilities "property-testing,boundary-analysis,sublinear-optimization"
-```
+**Native TypeScript coordination (replaces bash commands):**
+
+All swarm integration is handled automatically via AQE hooks (Agentic QE native hooks) shown above. The agent coordinates through:
+
+- **Memory Store**: Shared context via `this.memoryStore.store()` and `this.memoryStore.retrieve()`
+- **Event Bus**: Real-time coordination via `this.eventBus.emit()` and event handlers
+- **Hook Manager**: Advanced verification via `VerificationHookManager`
+
+No external bash commands needed - all coordination is built into the agent's lifecycle hooks.
 
 ## Framework Integration
 
@@ -272,20 +415,51 @@ describe('API Contract Tests', () => {
 ## Neural Pattern Integration
 
 ### Learning from Test Results
-```bash
-# Train neural patterns from test execution data
-npx claude-flow@alpha neural patterns \
-  --action "learn" \
-  --operation "test-generation" \
-  --outcome "${TEST_RESULTS}"
+
+**Native TypeScript neural integration:**
+
+```typescript
+// Store neural patterns from test results
+await this.memoryStore.store('aqe/neural/patterns/test-generation', {
+  operation: 'test-generation',
+  outcome: testResults,
+  patterns: identifiedPatterns,
+  confidence: 0.95,
+  timestamp: Date.now()
+}, {
+  partition: 'neural',
+  ttl: 2592000 // 30 days
+});
+
+// Emit neural learning event
+this.eventBus.emit('neural:pattern-learned', {
+  agentId: this.agentId,
+  operation: 'test-generation',
+  confidence: 0.95
+});
 ```
 
 ### Predictive Test Generation
-```bash
-# Use neural patterns to predict optimal test strategies
-npx claude-flow@alpha neural predict \
-  --model-id "test-generation-model" \
-  --input "${CODE_ANALYSIS}"
+
+**Native TypeScript prediction:**
+
+```typescript
+// Retrieve neural patterns for prediction
+const patterns = await this.memoryStore.retrieve('aqe/neural/patterns/test-generation', {
+  partition: 'neural'
+});
+
+// Use patterns for intelligent test strategy selection
+const predictedStrategy = this.predictOptimalStrategy(codeAnalysis, patterns);
+
+// Store prediction outcome
+await this.memoryStore.store('aqe/neural/predictions', {
+  input: codeAnalysis,
+  strategy: predictedStrategy,
+  timestamp: Date.now()
+}, {
+  partition: 'neural'
+});
 ```
 
 ## Commands

package/.claude/agents/qe-visual-tester.md

@@ -13,17 +13,8 @@ capabilities:
   - pixel-diff-analysis
   - responsive-testing
   - color-contrast-validation
-hooks:
-  pre_task:
-    - "npx claude-flow@alpha hooks pre-task --description 'Visual Tester: Initializing visual testing workflow'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/visual/baselines'"
-    - "npx claude-flow@alpha memory retrieve --key 'aqe/visual/test-config'"
-  post_task:
-    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/visual/test-results' --value '${VISUAL_TEST_RESULTS}'"
-    - "npx claude-flow@alpha memory store --key 'aqe/visual/regressions' --value '${REGRESSIONS_DETECTED}'"
-  post_edit:
-    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/visual/baselines/${FILE_NAME}'"
+coordination:
+  protocol: aqe-hooks
 metadata:
   version: "2.0.0"
   frameworks: ["playwright", "cypress", "puppeteer", "selenium"]
@@ -167,47 +158,80 @@ const accessibilityResults = await validateAccessibility({
 });
 ```
 
-## Integration Points
-
-### Memory Coordination
-```bash
-# Store baseline screenshots
-npx claude-flow@alpha memory store --key "aqe/visual/baselines/${VERSION}" --value "${BASELINE_DATA}"
+## Coordination Protocol
 
-# Store visual test results
-npx claude-flow@alpha memory store --key "aqe/visual/test-results/${TEST_RUN_ID}" --value "${TEST_RESULTS}"
+This agent uses **AQE hooks (Agentic QE native hooks)** for coordination (zero external dependencies, 100-500x faster).
+
+**Automatic Lifecycle Hooks:**
+```typescript
+protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
+  // Retrieve baselines
+  const baselines = await this.memoryStore.retrieve(`aqe/visual/baselines/${this.version}`, {
+    partition: 'visual_baselines'
+  });
+
+  // Retrieve test configuration
+  const testConfig = await this.memoryStore.retrieve('aqe/visual/test-config', {
+    partition: 'configuration'
+  });
+
+  this.eventBus.emit('visual-tester:starting', {
+    agentId: this.agentId,
+    pagesCount: testConfig.pages.length
+  });
+}
 
-# Store detected regressions
-npx claude-flow@alpha memory store --key "aqe/visual/regressions/${BUILD_ID}" --value "${REGRESSIONS}"
+protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
+  // Store visual test results
+  await this.memoryStore.store(`aqe/visual/test-results/${data.result.testRunId}`, data.result, {
+    partition: 'visual_results',
+    ttl: 86400
+  });
+
+  // Store detected regressions
+  if (data.result.regressions.length > 0) {
+    await this.memoryStore.store(`aqe/visual/regressions/${data.result.buildId}`, data.result.regressions, {
+      partition: 'regressions'
+    });
+  }
 
-# Store accessibility reports
-npx claude-flow@alpha memory store --key "aqe/visual/accessibility/${PAGE}" --value "${A11Y_REPORT}"
+  // Store accessibility reports
+  await this.memoryStore.store(`aqe/visual/accessibility/${data.result.page}`, data.result.a11yReport, {
+    partition: 'accessibility'
+  });
 
-# Store cross-browser results
-npx claude-flow@alpha memory store --key "aqe/visual/cross-browser/${BROWSER}" --value "${BROWSER_RESULTS}"
+  this.eventBus.emit('visual-tester:completed', {
+    agentId: this.agentId,
+    pagesTested: data.result.pagesTested,
+    regressionsFound: data.result.regressions.length
+  });
+}
 ```
 
-### EventBus Integration
-```javascript
+**Event Bus Integration:**
+```typescript
 // Subscribe to visual testing events
-eventBus.subscribe('visual:regression-detected', (event) => {
-  qualityGate.blockDeployment(event.severity);
-});
-
-eventBus.subscribe('visual:baseline-updated', (event) => {
-  notificationAgent.notifyTeam('New visual baseline created');
+this.registerEventHandler({
+  eventType: 'visual:regression-detected',
+  handler: async (event) => {
+    await this.qualityGate.blockDeployment(event.severity);
+  }
 });
 
-eventBus.subscribe('visual:accessibility-violation', (event) => {
-  complianceAgent.logViolation(event.violation);
+this.registerEventHandler({
+  eventType: 'visual:baseline-updated',
+  handler: async (event) => {
+    await this.notificationAgent.notifyTeam('New visual baseline created');
+  }
 });
+```
 
-// Broadcast visual testing events
-eventBus.publish('visual:test-complete', {
-  test_run_id: 'vt-123',
-  pages_tested: 15,
-  regressions_found: 2,
-  accessibility_score: 94
+**Advanced Verification:**
+```typescript
+const hookManager = new VerificationHookManager(this.memoryStore);
+const verification = await hookManager.executePreTaskVerification({
+  task: 'visual-regression-test',
+  context: { requiredVars: ['BASELINE_VERSION'], minMemoryMB: 2048 }
 });
 ```
 
@@ -244,31 +268,8 @@ eventBus.publish('visual:test-complete', {
 ## Coordination Protocol
 
 ### Swarm Integration
-```bash
-# Initialize visual testing workflow
-npx claude-flow@alpha task orchestrate \
-  --task "Execute visual regression tests across all pages" \
-  --agents "qe-visual-tester,qe-test-executor" \
-  --strategy "parallel-cross-browser"
-
-# Spawn visual testing agents
-npx claude-flow@alpha agent spawn \
-  --type "visual-tester" \
-  --capabilities "screenshot-comparison,accessibility-validation"
-```
 
-### Neural Pattern Training
-```bash
-# Train AI visual diff patterns
-npx claude-flow@alpha neural train \
-  --pattern-type "visual-regression" \
-  --training-data "historical-regressions"
-
-# Predict visual regression risk
-npx claude-flow@alpha neural predict \
-  --model-id "visual-risk-model" \
-  --input "${CODE_CHANGES}"
-```
+All swarm coordination is handled via **AQE hooks (Agentic QE native hooks)** and the EventBus. Use Claude Code's Task tool to spawn agents and orchestrate workflows - the native hooks handle all coordination automatically without external MCP commands.
 
 ## Visual Comparison Algorithms
 

package/.claude/aqe-fleet.json

@@ -1,5 +1,5 @@
 {
-  "fleetId": "aqe-fleet-1759299421013",
+  "fleetId": "aqe-fleet-1759773240987",
   "version": "2.0.0",
   "topology": "hierarchical",
   "maxAgents": 6,
@@ -21,7 +21,7 @@
     "qe-api-contract-validator",
     "qe-flaky-test-hunter"
   ],
-  "created": "2025-10-01T06:17:01.013Z",
+  "created": "2025-10-06T17:54:00.987Z",
   "status": "active",
   "configuration": {
     "coordination": {
@@ -42,6 +42,6 @@
   "metadata": {
     "packageVersion": "2.0.0",
     "claudeFlowVersion": "alpha",
-    "initDate": "2025-10-01T06:17:01.013Z"
+    "initDate": "2025-10-06T17:54:00.987Z"
   }
 }