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

package/assets/skills/testability-scoring/scripts/run-assessment.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+set -e
+
+# Testability Scoring Assessment Runner
+# Usage: ./run-assessment.sh <URL> [browser]
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
+TEST_FILE="$PROJECT_ROOT/tests/testability-scoring/testability-scoring.spec.js"
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Check if URL provided
+if [ -z "$1" ]; then
+    echo -e "${RED}Error: URL required${NC}"
+    echo "Usage: $0 <URL> [browser]"
+    echo "Example: $0 https://example.com chromium"
+    exit 1
+fi
+
+TARGET_URL="$1"
+BROWSER="${2:-chromium}"
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${GREEN}🎯 Testability Assessment${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo -e "  ${YELLOW}URL:${NC}     $TARGET_URL"
+echo -e "  ${YELLOW}Browser:${NC} $BROWSER"
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Change to project root
+cd "$PROJECT_ROOT"
+
+# Run Playwright tests with TEST_URL environment variable
+echo -e "${YELLOW}⏳ Running assessment...${NC}\n"
+
+TEST_URL="$TARGET_URL" npx playwright test "$TEST_FILE" --project="$BROWSER" --workers=1
+
+# Check if tests passed
+if [ $? -eq 0 ]; then
+    echo ""
+    echo -e "${GREEN}✅ Assessment completed successfully!${NC}"
+    
+    # Find the latest JSON report
+    LATEST_JSON=$(ls -t "$PROJECT_ROOT/tests/reports/testability-results-"*.json 2>/dev/null | head -1)
+    
+    if [ -n "$LATEST_JSON" ]; then
+        # Generate HTML report
+        echo -e "\n${YELLOW}📊 Generating HTML report...${NC}\n"
+        node "$SCRIPT_DIR/generate-html-report.js" "$LATEST_JSON"
+        
+        echo ""
+        echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+        echo -e "${GREEN}✓ Complete! Check your browser for the report.${NC}"
+        echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    else
+        echo -e "${YELLOW}⚠️  JSON report not found${NC}"
+    fi
+else
+    echo -e "\n${RED}❌ Assessment failed${NC}"
+    exit 1
+fi

package/assets/skills/v3-qe-chaos-resilience/SKILL.md

@@ -0,0 +1,238 @@
+---
+name: "V3 QE Chaos Resilience"
+description: "Chaos engineering and resilience testing including fault injection, load testing, and system recovery validation."
+---
+
+# V3 QE Chaos Resilience
+
+## Purpose
+
+Guide the use of v3's chaos engineering capabilities including controlled fault injection, load/stress testing, resilience validation, and disaster recovery testing.
+
+## Activation
+
+- When testing system resilience
+- When performing chaos experiments
+- When load/stress testing
+- When validating disaster recovery
+- When testing circuit breakers
+
+## Quick Start
+
+```bash
+# Run chaos experiment
+aqe-v3 chaos run --experiment network-latency --target api-service
+
+# Load test
+aqe-v3 chaos load --scenario peak-traffic --duration 30m
+
+# Stress test to breaking point
+aqe-v3 chaos stress --endpoint /api/users --max-users 10000
+
+# Test circuit breaker
+aqe-v3 chaos circuit-breaker --service payment-service
+```
+
+## Agent Workflow
+
+```typescript
+// Chaos experiment
+Task("Run chaos experiment", `
+  Execute controlled chaos on api-service:
+  - Inject 500ms network latency
+  - Monitor service health metrics
+  - Verify circuit breaker activation
+  - Measure recovery time
+  - Document findings
+`, "v3-qe-chaos-engineer")
+
+// Load testing
+Task("Performance load test", `
+  Run load test simulating Black Friday traffic:
+  - Ramp up to 10,000 concurrent users
+  - Maintain load for 30 minutes
+  - Monitor response times and error rates
+  - Identify bottlenecks
+  - Compare against SLAs
+`, "v3-qe-load-tester")
+```
+
+## Chaos Experiments
+
+### 1. Fault Injection
+
+```typescript
+await chaosEngineer.injectFault({
+  target: 'api-service',
+  fault: {
+    type: 'latency',
+    parameters: {
+      delay: '500ms',
+      jitter: '100ms',
+      percentage: 50
+    }
+  },
+  duration: '5m',
+  monitoring: {
+    metrics: ['response_time', 'error_rate', 'throughput'],
+    alerts: true
+  },
+  rollback: {
+    automatic: true,
+    trigger: 'error_rate > 10%'
+  }
+});
+```
+
+### 2. Load Testing
+
+```typescript
+await loadTester.execute({
+  scenario: 'peak-traffic',
+  profile: {
+    rampUp: '5m',
+    steadyState: '30m',
+    rampDown: '5m'
+  },
+  users: {
+    initial: 100,
+    target: 5000,
+    pattern: 'linear'
+  },
+  assertions: {
+    p95_latency: '<500ms',
+    error_rate: '<1%',
+    throughput: '>1000rps'
+  }
+});
+```
+
+### 3. Stress Testing
+
+```typescript
+await loadTester.stressTest({
+  endpoint: '/api/checkout',
+  strategy: 'step-increase',
+  steps: [100, 500, 1000, 2000, 5000],
+  stepDuration: '5m',
+  findBreakingPoint: true,
+  monitoring: {
+    resourceUtilization: true,
+    databaseConnections: true,
+    memoryUsage: true
+  }
+});
+```
+
+### 4. Resilience Validation
+
+```typescript
+await resilienceTester.validate({
+  scenarios: [
+    'database-failover',
+    'cache-failure',
+    'external-service-timeout',
+    'pod-termination'
+  ],
+  expectations: {
+    gracefulDegradation: true,
+    automaticRecovery: true,
+    dataIntegrity: true,
+    recoveryTime: '<30s'
+  }
+});
+```
+
+## Fault Types
+
+| Fault | Description | Use Case |
+|-------|-------------|----------|
+| Latency | Add network delay | Test timeouts |
+| Packet Loss | Drop network packets | Test retry logic |
+| CPU Stress | Consume CPU | Test resource limits |
+| Memory Pressure | Consume memory | Test OOM handling |
+| Disk Full | Fill disk space | Test disk errors |
+| Process Kill | Terminate process | Test recovery |
+
+## Chaos Report
+
+```typescript
+interface ChaosReport {
+  experiment: {
+    name: string;
+    target: string;
+    fault: FaultConfig;
+    duration: number;
+  };
+  results: {
+    hypothesis: string;
+    validated: boolean;
+    metrics: {
+      before: MetricSnapshot;
+      during: MetricSnapshot;
+      after: MetricSnapshot;
+    };
+    events: ChaosEvent[];
+    recovery: {
+      detected: boolean;
+      time: number;
+      automatic: boolean;
+    };
+  };
+  findings: {
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    description: string;
+    recommendation: string;
+  }[];
+  artifacts: {
+    logs: string;
+    metrics: string;
+    traces: string;
+  };
+}
+```
+
+## Safety Controls
+
+```yaml
+safety:
+  blast_radius:
+    max_affected_pods: 1
+    max_affected_percentage: 10
+
+  abort_conditions:
+    - error_rate > 50%
+    - p99_latency > 10s
+    - service_unavailable
+
+  excluded_environments:
+    - production-critical
+
+  required_approvals:
+    production: 2
+    staging: 0
+```
+
+## SLA Validation
+
+```typescript
+await resilienceTester.validateSLA({
+  slas: {
+    availability: 99.9,
+    p95_latency: 500,
+    error_rate: 0.1
+  },
+  period: '30d',
+  report: {
+    breaches: true,
+    trends: true,
+    projections: true
+  }
+});
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-chaos-engineer, v3-qe-load-tester, v3-qe-resilience-tester
+**Coordinator**: v3-qe-chaos-coordinator
+**Related Skills**: v3-qe-performance, v3-qe-security-compliance

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

@@ -0,0 +1,209 @@
+---
+name: "V3 QE Code Intelligence"
+description: "Knowledge graph-based code understanding with semantic search and 80% token reduction through intelligent context retrieval."
+---
+
+# V3 QE Code Intelligence
+
+## Purpose
+
+Guide the use of v3's code intelligence capabilities including knowledge graph construction, semantic code search, dependency mapping, and context-aware code understanding with significant token reduction.
+
+## Activation
+
+- When understanding unfamiliar code
+- When searching for code semantically
+- When analyzing dependencies
+- When building code knowledge graphs
+- When reducing context for AI operations
+
+## Quick Start
+
+```bash
+# Index codebase into knowledge graph
+aqe-v3 kg index --source src/ --incremental
+
+# Semantic code search
+aqe-v3 kg search "authentication middleware" --limit 10
+
+# Query dependencies
+aqe-v3 kg deps --file src/services/UserService.ts --depth 3
+
+# Get intelligent context
+aqe-v3 kg context --query "how does payment processing work"
+```
+
+## Agent Workflow
+
+```typescript
+// Build knowledge graph
+Task("Index codebase", `
+  Build knowledge graph for the project:
+  - Parse all TypeScript files in src/
+  - Extract entities (classes, functions, types)
+  - Map relationships (imports, calls, inheritance)
+  - Generate embeddings for semantic search
+  Store in AgentDB vector database.
+`, "v3-qe-knowledge-graph")
+
+// Semantic search
+Task("Find relevant code", `
+  Search for code related to "user authentication flow":
+  - Use semantic similarity (not just keyword)
+  - Include related functions and types
+  - Rank by relevance score
+  - Return with minimal context (80% token reduction)
+`, "v3-qe-semantic-searcher")
+```
+
+## Knowledge Graph Operations
+
+### 1. Codebase Indexing
+
+```typescript
+await knowledgeGraph.index({
+  source: 'src/**/*.ts',
+  extraction: {
+    entities: ['class', 'function', 'interface', 'type', 'variable'],
+    relationships: ['imports', 'calls', 'extends', 'implements', 'uses'],
+    metadata: ['jsdoc', 'complexity', 'lines']
+  },
+  embeddings: {
+    model: 'code-embedding',
+    dimensions: 384,
+    normalize: true
+  },
+  incremental: true  // Only index changed files
+});
+```
+
+### 2. Semantic Search
+
+```typescript
+await semanticSearcher.search({
+  query: 'payment processing with stripe',
+  options: {
+    similarity: 'cosine',
+    threshold: 0.7,
+    limit: 20,
+    includeContext: true
+  },
+  filters: {
+    fileTypes: ['.ts', '.tsx'],
+    excludePaths: ['node_modules', 'dist']
+  }
+});
+```
+
+### 3. Dependency Analysis
+
+```typescript
+await dependencyMapper.analyze({
+  entry: 'src/services/OrderService.ts',
+  depth: 3,
+  direction: 'both',  // imports and importedBy
+  output: {
+    graph: true,
+    metrics: {
+      afferentCoupling: true,
+      efferentCoupling: true,
+      instability: true
+    }
+  }
+});
+```
+
+## Token Reduction Strategy
+
+```typescript
+// Get context with 80% token reduction
+const context = await codeIntelligence.getOptimizedContext({
+  query: 'implement user registration',
+  budget: 4000,  // max tokens
+  strategy: {
+    relevanceRanking: true,
+    summarization: true,
+    codeCompression: true,
+    deduplication: true
+  },
+  include: {
+    signatures: true,
+    implementations: 'relevant-only',
+    comments: 'essential',
+    examples: 'top-3'
+  }
+});
+```
+
+## Knowledge Graph Schema
+
+```typescript
+interface KnowledgeGraph {
+  entities: {
+    id: string;
+    type: 'class' | 'function' | 'interface' | 'type' | 'file';
+    name: string;
+    file: string;
+    line: number;
+    embedding: number[];
+    metadata: Record<string, any>;
+  }[];
+  relationships: {
+    source: string;
+    target: string;
+    type: 'imports' | 'calls' | 'extends' | 'implements' | 'uses';
+    weight: number;
+  }[];
+  indexes: {
+    byName: Map<string, string[]>;
+    byFile: Map<string, string[]>;
+    byType: Map<string, string[]>;
+  };
+}
+```
+
+## Search Results
+
+```typescript
+interface SearchResult {
+  entity: {
+    name: string;
+    type: string;
+    file: string;
+    line: number;
+  };
+  relevance: number;
+  snippet: string;
+  context: {
+    before: string[];
+    after: string[];
+    related: string[];
+  };
+  explanation: string;
+}
+```
+
+## CLI Examples
+
+```bash
+# Full reindex
+aqe-v3 kg index --source src/ --force
+
+# Search with filters
+aqe-v3 kg search "database connection" --type function --file "*.service.ts"
+
+# Show entity details
+aqe-v3 kg show --entity UserService --relations
+
+# Export graph
+aqe-v3 kg export --format dot --output codebase.dot
+
+# Statistics
+aqe-v3 kg stats
+```
+
+## Coordination
+
+**Primary Agents**: v3-qe-knowledge-graph, v3-qe-semantic-searcher, v3-qe-dependency-mapper
+**Coordinator**: v3-qe-code-intelligence-coordinator
+**Related Skills**: v3-qe-test-generation, v3-qe-defect-intelligence