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

package/assets/skills/swarm-orchestration/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: "Swarm Orchestration"
+description: "Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems."
+---
+
+# Swarm Orchestration
+
+## What This Skill Does
+
+Orchestrates multi-agent swarms using agentic-flow's advanced coordination system. Supports mesh, hierarchical, and adaptive topologies with automatic task distribution, load balancing, and fault tolerance.
+
+## Prerequisites
+
+- agentic-flow v1.5.11+
+- Node.js 18+
+- Understanding of distributed systems (helpful)
+
+## Quick Start
+
+```bash
+# Initialize swarm
+npx agentic-flow hooks swarm-init --topology mesh --max-agents 5
+
+# Spawn agents
+npx agentic-flow hooks agent-spawn --type coder
+npx agentic-flow hooks agent-spawn --type tester
+npx agentic-flow hooks agent-spawn --type reviewer
+
+# Orchestrate task
+npx agentic-flow hooks task-orchestrate \
+  --task "Build REST API with tests" \
+  --mode parallel
+```
+
+## Topology Patterns
+
+### 1. Mesh (Peer-to-Peer)
+```typescript
+// Equal peers, distributed decision-making
+await swarm.init({
+  topology: 'mesh',
+  agents: ['coder', 'tester', 'reviewer'],
+  communication: 'broadcast'
+});
+```
+
+### 2. Hierarchical (Queen-Worker)
+```typescript
+// Centralized coordination, specialized workers
+await swarm.init({
+  topology: 'hierarchical',
+  queen: 'architect',
+  workers: ['backend-dev', 'frontend-dev', 'db-designer']
+});
+```
+
+### 3. Adaptive (Dynamic)
+```typescript
+// Automatically switches topology based on task
+await swarm.init({
+  topology: 'adaptive',
+  optimization: 'task-complexity'
+});
+```
+
+## Task Orchestration
+
+### Parallel Execution
+```typescript
+// Execute tasks concurrently
+const results = await swarm.execute({
+  tasks: [
+    { agent: 'coder', task: 'Implement API endpoints' },
+    { agent: 'frontend', task: 'Build UI components' },
+    { agent: 'tester', task: 'Write test suite' }
+  ],
+  mode: 'parallel',
+  timeout: 300000 // 5 minutes
+});
+```
+
+### Pipeline Execution
+```typescript
+// Sequential pipeline with dependencies
+await swarm.pipeline([
+  { stage: 'design', agent: 'architect' },
+  { stage: 'implement', agent: 'coder', after: 'design' },
+  { stage: 'test', agent: 'tester', after: 'implement' },
+  { stage: 'review', agent: 'reviewer', after: 'test' }
+]);
+```
+
+### Adaptive Execution
+```typescript
+// Let swarm decide execution strategy
+await swarm.autoOrchestrate({
+  goal: 'Build production-ready API',
+  constraints: {
+    maxTime: 3600,
+    maxAgents: 8,
+    quality: 'high'
+  }
+});
+```
+
+## Memory Coordination
+
+```typescript
+// Share state across swarm
+await swarm.memory.store('api-schema', {
+  endpoints: [...],
+  models: [...]
+});
+
+// Agents read shared memory
+const schema = await swarm.memory.retrieve('api-schema');
+```
+
+## Advanced Features
+
+### Load Balancing
+```typescript
+// Automatic work distribution
+await swarm.enableLoadBalancing({
+  strategy: 'dynamic',
+  metrics: ['cpu', 'memory', 'task-queue']
+});
+```
+
+### Fault Tolerance
+```typescript
+// Handle agent failures
+await swarm.setResiliency({
+  retry: { maxAttempts: 3, backoff: 'exponential' },
+  fallback: 'reassign-task'
+});
+```
+
+### Performance Monitoring
+```typescript
+// Track swarm metrics
+const metrics = await swarm.getMetrics();
+// { throughput, latency, success_rate, agent_utilization }
+```
+
+## Integration with Hooks
+
+```bash
+# Pre-task coordination
+npx agentic-flow hooks pre-task --description "Build API"
+
+# Post-task synchronization
+npx agentic-flow hooks post-task --task-id "task-123"
+
+# Session restore
+npx agentic-flow hooks session-restore --session-id "swarm-001"
+```
+
+## Best Practices
+
+1. **Start small**: Begin with 2-3 agents, scale up
+2. **Use memory**: Share context through swarm memory
+3. **Monitor metrics**: Track performance and bottlenecks
+4. **Enable hooks**: Automatic coordination and sync
+5. **Set timeouts**: Prevent hung tasks
+
+## Troubleshooting
+
+### Issue: Agents not coordinating
+**Solution**: Verify memory access and enable hooks
+
+### Issue: Poor performance
+**Solution**: Check topology (use adaptive) and enable load balancing
+
+## Learn More
+
+- Swarm Guide: docs/swarm/orchestration.md
+- Topology Patterns: docs/swarm/topologies.md
+- Hooks Integration: docs/hooks/coordination.md

package/assets/skills/tdd-london-chicago/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: tdd-london-chicago
+description: "Apply London (mock-based) and Chicago (state-based) TDD schools. Use when practicing test-driven development or choosing testing style for your context."
+category: development-practices
+priority: high
+tokenEstimate: 1100
+agents: [qe-test-generator, qe-test-implementer, qe-test-refactorer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [tdd, testing, london-school, chicago-school, red-green-refactor, mocks]
+---
+
+# Test-Driven Development: London & Chicago Schools
+
+<default_to_action>
+When implementing TDD or choosing testing style:
+1. IDENTIFY code type: domain logic → Chicago, external deps → London
+2. WRITE failing test first (Red phase)
+3. IMPLEMENT minimal code to pass (Green phase)
+4. REFACTOR while keeping tests green (Refactor phase)
+5. REPEAT cycle for next functionality
+
+**Quick Style Selection:**
+- Pure functions/calculations → Chicago (real objects, state verification)
+- Controllers/services with deps → London (mocks, interaction verification)
+- Value objects → Chicago (test final state)
+- API integrations → London (mock external services)
+- Mix both in practice (London for controllers, Chicago for domain)
+
+**Critical Success Factors:**
+- Tests drive design, not just verify it
+- Make tests fail first to ensure they test something
+- Write minimal code - no features beyond what's tested
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Starting new feature with test-first approach
+- Refactoring legacy code with test coverage
+- Teaching TDD practices to team
+- Choosing between mocking vs real objects
+
+### TDD Cycle
+| Phase | Action | Discipline |
+|-------|--------|------------|
+| **Red** | Write failing test | Verify it fails, check message is clear |
+| **Green** | Minimal code to pass | No extra features, don't refactor |
+| **Refactor** | Improve structure | Keep tests passing, no new functionality |
+
+### School Comparison
+| Aspect | Chicago (Classicist) | London (Mockist) |
+|--------|---------------------|------------------|
+| Collaborators | Real objects | Mocks/stubs |
+| Verification | State (assert outcomes) | Interaction (assert calls) |
+| Isolation | Lower (integrated) | Higher (unit only) |
+| Refactoring | Easier | Harder (mocks break) |
+| Design feedback | Emerges from use | Explicit from start |
+
+### Agent Coordination
+- `qe-test-generator`: Generate tests in both schools
+- `qe-test-implementer`: Implement minimal code (Green)
+- `qe-test-refactorer`: Safe refactoring (Refactor)
+
+---
+
+## Chicago School (State-Based)
+
+**Philosophy:** Test observable behavior through public API. Keep tests close to consumer usage.
+
+```javascript
+// State verification - test final outcome
+describe('Order', () => {
+  it('calculates total with tax', () => {
+    const order = new Order();
+    order.addItem(new Product('Widget', 10.00), 2);
+    order.addItem(new Product('Gadget', 15.00), 1);
+
+    expect(order.totalWithTax(0.10)).toBe(38.50);
+  });
+});
+```
+
+**When Chicago Shines:**
+- Domain logic with clear state
+- Algorithms and calculations
+- Value objects (`Money`, `Email`)
+- Simple collaborations
+- Learning new domain
+
+---
+
+## London School (Mock-Based)
+
+**Philosophy:** Test each unit in isolation. Focus on how objects collaborate.
+
+```javascript
+// Interaction verification - test method calls
+describe('Order', () => {
+  it('delegates tax calculation', () => {
+    const taxCalculator = {
+      calculateTax: jest.fn().mockReturnValue(3.50)
+    };
+    const order = new Order(taxCalculator);
+    order.addItem({ price: 10 }, 2);
+
+    order.totalWithTax();
+
+    expect(taxCalculator.calculateTax).toHaveBeenCalledWith(20.00);
+  });
+});
+```
+
+**When London Shines:**
+- External integrations (DB, APIs)
+- Command patterns with side effects
+- Complex workflows
+- Slow operations (network, I/O)
+
+---
+
+## Mixed Approach (Recommended)
+
+```javascript
+// London for controller (external deps)
+describe('OrderController', () => {
+  it('creates order and sends confirmation', async () => {
+    const orderService = { create: jest.fn().mockResolvedValue({ id: 123 }) };
+    const emailService = { send: jest.fn() };
+
+    const controller = new OrderController(orderService, emailService);
+    await controller.placeOrder(orderData);
+
+    expect(orderService.create).toHaveBeenCalledWith(orderData);
+    expect(emailService.send).toHaveBeenCalled();
+  });
+});
+
+// Chicago for domain logic
+describe('OrderService', () => {
+  it('applies discount when threshold met', () => {
+    const service = new OrderService();
+    const order = service.create({ items: [...], total: 150 });
+
+    expect(order.discount).toBe(15); // 10% off > $100
+  });
+});
+```
+
+---
+
+## Common Pitfalls
+
+### ❌ Over-Mocking (London)
+```javascript
+// BAD - mocking everything
+const product = { getName: jest.fn(), getPrice: jest.fn() };
+```
+**Better:** Only mock external dependencies.
+
+### ❌ Mocking Internals
+```javascript
+// BAD - testing private methods
+expect(order._calculateSubtotal).toHaveBeenCalled();
+```
+**Better:** Test public behavior only.
+
+### ❌ Test Pain = Design Pain
+- Need many mocks? → Too many dependencies
+- Hard to set up? → Constructor does too much
+- Can't test without database? → Coupling issue
+
+---
+
+## Agent-Assisted TDD
+
+```typescript
+// Agent generates tests in both schools
+await Task("Generate Tests", {
+  style: 'chicago',      // or 'london'
+  target: 'src/domain/Order.ts',
+  focus: 'state-verification'  // or 'collaboration-patterns'
+}, "qe-test-generator");
+
+// Agent-human ping-pong TDD
+// Human writes test concept
+const testIdea = "Order applies 10% discount when total > $100";
+
+// Agent generates formal failing test (Red)
+await Task("Create Failing Test", testIdea, "qe-test-generator");
+
+// Human writes minimal code (Green)
+
+// Agent suggests refactorings
+await Task("Suggest Refactorings", { preserveTests: true }, "qe-test-refactorer");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/tdd/
+├── test-plan/*        - TDD session plans
+├── red-phase/*        - Failing tests generated
+├── green-phase/*      - Implementation code
+└── refactor-phase/*   - Refactoring suggestions
+```
+
+### Fleet Coordination
+```typescript
+const tddFleet = await FleetManager.coordinate({
+  workflow: 'red-green-refactor',
+  agents: {
+    testGenerator: 'qe-test-generator',
+    testExecutor: 'qe-test-executor',
+    qualityAnalyzer: 'qe-quality-analyzer'
+  },
+  mode: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [agentic-quality-engineering](../agentic-quality-engineering/) - TDD with agent coordination
+- [refactoring-patterns](../refactoring-patterns/) - Refactor phase techniques
+- [api-testing-patterns](../api-testing-patterns/) - London school for API testing
+
+---
+
+## Remember
+
+**Chicago:** Test state, use real objects, refactor freely
+**London:** Test interactions, mock dependencies, design interfaces first
+**Both:** Write the test first, make it pass, refactor
+
+Neither is "right." Choose based on context. Mix as needed. Goal: well-designed, tested code.
+
+**With Agents:** Agents excel at generating tests, validating green phase, and suggesting refactorings. Use agents to maintain TDD discipline while humans focus on design decisions.

package/assets/skills/technical-writing/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: technical-writing
+description: "Write clear, engaging technical content from real experience. Use when writing blog posts, documentation, tutorials, or technical articles."
+category: communication
+priority: medium
+tokenEstimate: 800
+agents: [qe-quality-analyzer, qe-api-contract-validator]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-03
+dependencies: []
+quick_reference_card: true
+tags: [writing, documentation, communication, blogs, tutorials]
+---
+
+# Technical Writing
+
+<default_to_action>
+When writing technical content:
+1. LEAD with value (what will reader learn/gain?)
+2. SHOW, don't tell (specific examples, code, numbers)
+3. STRUCTURE for scanning (headers, bold, short paragraphs)
+4. CUT ruthlessly (every sentence must earn its place)
+5. BE honest about trade-offs
+
+**Blog Post Structure:**
+```markdown
+# Title (specific promise)
+
+## Opening (2-3 paragraphs)
+- Hook: The problem or insight
+- Context: Why this matters
+- Promise: What they'll learn
+
+## Body (3-5 sections)
+- One clear idea per section
+- Support with examples/code/data
+
+## Closing
+- Key takeaway (1-2 sentences)
+- Action reader can take
+```
+
+**Before/After:**
+❌ "We implemented a comprehensive testing strategy..."
+✅ "We moved exploratory testing into sprint planning. QE now pairs with devs during story refinement."
+</default_to_action>
+
+## Quick Reference Card
+
+### Core Principles
+
+| Principle | Bad | Good |
+|-----------|-----|------|
+| **Lead with value** | "In today's landscape..." | "Here's how we cut bugs 60%" |
+| **Show, don't tell** | "We improved testing" | "Bug detection: 12→47 per sprint" |
+| **Be specific** | "Performance improved" | "Response time: 2.3s→180ms" |
+| **Honest trade-offs** | "This approach is best" | "TDD slowed velocity 20%, reduced bugs 75%" |
+
+### Words to Cut
+
+| Kill | Reason |
+|------|--------|
+| basically, actually, probably | Hedge words |
+| leverage, synergy, paradigm | Corporate speak |
+| very, really, quite | Unnecessary qualifiers |
+| it should be noted that | Just note it |
+
+---
+
+## Audience-Specific Writing
+
+### For Developers
+- Lead with code or concrete problem
+- Show implementation details
+- Discuss trade-offs and alternatives
+- Link to repos or examples
+
+### For QA/QE
+- Start with testing challenge
+- Show strategy, not just tools
+- Include risk assessment
+- Provide adaptable heuristics
+
+### For Leadership
+- Open with business impact
+- Use metrics that matter
+- Connect technical to outcomes
+- Keep technical details concise
+
+---
+
+## Editing Checklist
+
+Before publishing:
+- [ ] Title promises something specific
+- [ ] Opening hooks in 30 seconds
+- [ ] Claims backed by examples
+- [ ] All unnecessary words cut
+- [ ] Code examples tested and correct
+- [ ] Takeaway crystal clear
+- [ ] Would send to respected colleague
+
+---
+
+## Example Transformations
+
+**Before:**
+"We decided to implement a more comprehensive testing strategy that would allow us to catch bugs earlier in the development lifecycle."
+
+**After:**
+"We moved exploratory testing into sprint planning. QE now pairs with devs during story refinement, identifying risks before code is written."
+
+---
+
+**Before:**
+"The benefits of this approach are numerous and include improved quality, faster feedback loops, and better team collaboration."
+
+**After:**
+"Three outcomes: bugs found 2 days earlier on average, 30% fewer regression issues, and devs now ask QE for input during design."
+
+---
+
+## Agent Integration
+
+```typescript
+// Generate documentation from code
+const docs = await Task("Generate Docs", {
+  source: 'src/services/PaymentService.ts',
+  format: 'markdown',
+  includeExamples: true
+}, "qe-quality-analyzer");
+
+// Review documentation quality
+const review = await Task("Review Docs", {
+  files: ['README.md', 'docs/api.md'],
+  checkClarity: true,
+  checkCodeExamples: true
+}, "qe-quality-analyzer");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/technical-writing/
+├── generated-docs/*   - Auto-generated documentation
+├── reviews/*          - Documentation review findings
+└── templates/*        - Reusable doc templates
+```
+
+### Fleet Coordination
+```typescript
+const docsFleet = await FleetManager.coordinate({
+  strategy: 'documentation',
+  agents: [
+    'qe-quality-analyzer',         // Generate and review
+    'qe-api-contract-validator'    // API doc accuracy
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [bug-reporting-excellence](../bug-reporting-excellence/) - Technical bug writing
+- [code-review-quality](../code-review-quality/) - Review documentation
+
+---
+
+## Remember
+
+**You're not writing to impress.** You're writing to help people solve problems you've already solved. Be the colleague you wish you'd had.
+
+**Write from experience.** Only write about what you've done in production. If exploring, say so.