agentic-flow 1.9.0 → 1.9.1

package/agentic-flow/docs/architecture/PACKAGE_STRUCTURE.md

@@ -1,199 +0,0 @@
-# agentic-flow Package Structure
-
-## Overview
-
-The `agentic-flow` npm package includes all necessary files for agent execution, including 76 pre-built agent definitions in the `.claude/agents/` directory.
-
-## Package Contents
-
-When you install `agentic-flow` via npm, you get:
-
-```
-agentic-flow/
-├── dist/                    # Compiled JavaScript
-│   ├── cli-proxy.js         # Main CLI entry point
-│   ├── agents/              # Agent implementations
-│   ├── router/              # Multi-provider router
-│   └── utils/               # Utilities
-├── .claude/                 # Agent definitions (76 files)
-│   └── agents/
-│       ├── core/            # Core agents (coder, planner, reviewer, etc.)
-│       ├── consensus/       # Distributed consensus agents
-│       ├── github/          # GitHub integration agents
-│       ├── flow-nexus/      # Flow Nexus cloud agents
-│       ├── sparc/           # SPARC methodology agents
-│       └── ...              # More specialized categories
-├── docs/                    # Documentation
-├── README.md
-└── LICENSE
-```
-
-## Agent Loading System
-
-### Package Agents (Bundled)
-
-All 76 agent definitions are included in the npm package at:
-```
-node_modules/agentic-flow/.claude/agents/
-```
-
-These are automatically loaded when you run `npx agentic-flow`.
-
-### Local Agents (User Custom)
-
-You can create custom agents in your project:
-```
-your-project/
-└── .claude/
-    └── agents/
-        └── custom/
-            └── my-agent.md
-```
-
-**Local agents override package agents** with the same relative path.
-
-## Agent Discovery Order
-
-1. **Package agents**: Load from `node_modules/agentic-flow/.claude/agents/`
-2. **Local agents**: Load from `./claude/agents/` (overrides package agents if same path)
-3. **Custom directory**: Use `--agents-dir` flag to specify alternative location
-
-## Verification
-
-To verify your installation includes all agents:
-
-```bash
-# List all available agents
-npx agentic-flow --list
-
-# Should show 73 agents (76 files, some without proper frontmatter)
-```
-
-## Custom Agent Creation
-
-Create custom agents that augment or replace package agents:
-
-```bash
-# Interactive creation
-npx agentic-flow agent create
-
-# Manual creation
-mkdir -p .claude/agents/custom
-cat > .claude/agents/custom/my-agent.md << 'EOF'
----
-name: my-agent
-description: My custom agent
----
-
-You are a specialized agent for [purpose].
-Follow these guidelines:
-- [guideline 1]
-- [guideline 2]
-EOF
-```
-
-## Package Maintenance
-
-### Building
-
-```bash
-npm run build
-```
-
-### Verifying Package Structure
-
-```bash
-./scripts/verify-package.sh
-```
-
-### Creating Package
-
-```bash
-npm pack
-```
-
-### Testing Installation
-
-```bash
-# Install in test directory
-mkdir -p /tmp/test-install
-cd /tmp/test-install
-npm install /path/to/agentic-flow-1.1.2.tgz
-
-# Verify agents loaded
-./node_modules/.bin/agentic-flow --list
-```
-
-## Environment Configuration
-
-The package automatically loads `.env` files from:
-1. Current directory
-2. Parent directories (recursively up to root)
-
-This ensures API keys work from any directory:
-
-```bash
-# Works from project root
-cd /workspaces/myproject
-npx agentic-flow --agent coder --task "test" --provider gemini
-
-# Also works from subdirectory (finds parent .env)
-cd /workspaces/myproject/src
-npx agentic-flow --agent coder --task "test" --provider gemini
-```
-
-## Files Included in Package
-
-See `package.json`:
-```json
-{
-  "files": [
-    "dist",
-    "docs",
-    ".claude",
-    "README.md",
-    "LICENSE"
-  ]
-}
-```
-
-## Files Excluded (.npmignore)
-
-- Source files (`src/`, `*.ts`)
-- Tests (`tests/`, `validation/`)
-- Development files (`.env`, `tsconfig.json`)
-- Runtime state directories (`.claude-flow/`, `.swarm/`, `memory/`)
-- ONNX models (`*.onnx`, `models/`)
-
-## Agent Categories
-
-The 76 included agents span:
-
-- **Core** (5): coder, planner, researcher, reviewer, tester
-- **Consensus** (7): Byzantine, CRDT, Gossip, Raft, Quorum, etc.
-- **GitHub** (14): PR management, issue tracking, release automation
-- **Flow Nexus** (9): Cloud sandboxes, neural networks, workflows
-- **SPARC** (4): Specification, Pseudocode, Architecture, Refinement
-- **Optimization** (5): Resource allocation, load balancing, benchmarks
-- **Goal Planning** (2): GOAP, sublinear algorithms
-- **Swarm** (3): Hierarchical, mesh, adaptive coordination
-- **Payments** (1): Agentic payment authorization
-- **Templates** (10): Automation, orchestration, migration
-- **Testing** (2): TDD, production validation
-- **Specialized** (varies): Analysis, architecture, data, development, DevOps, documentation
-
-## Total Agent Count
-
-- **76 agent files** in `.claude/agents/`
-- **73 valid agents** (3 files missing required frontmatter)
-- **All core agents** (coder, planner, researcher, reviewer, tester) working
-
-## Summary
-
-✅ All 76 agent definitions are packaged and distributed via npm
-✅ Agent loading works automatically from `node_modules/`
-✅ Local `.claude/agents/` can override package agents
-✅ Environment variable loading works recursively
-✅ Package structure verified and tested
-
-The `.claude/` directory is a first-class part of the npm package, ensuring all users have immediate access to the complete agent library upon installation.

package/agentic-flow/docs/architecture/QUIC-IMPLEMENTATION-SUMMARY.md

@@ -1,490 +0,0 @@
-# QUIC Transport Implementation Summary
-
-## Overview
-
-This document summarizes the implementation of QUIC transport integration for multi-agent swarm coordination in agentic-flow.
-
-**Implementation Date**: 2025-10-16
-**Branch**: feat/quic-optimization
-**Status**: Complete ✅
-
-## Components Implemented
-
-### 1. QuicCoordinator (`src/swarm/quic-coordinator.ts`)
-
-**Purpose**: Manages agent-to-agent communication in multi-agent swarms using QUIC transport.
-
-**Key Features**:
-- ✅ Support for 4 topology types (mesh, hierarchical, ring, star)
-- ✅ Topology-aware message routing
-- ✅ Real-time state synchronization (configurable interval)
-- ✅ Automatic heartbeat monitoring
-- ✅ Per-agent statistics tracking (messages sent/received, latency)
-- ✅ Connection pooling integration
-- ✅ QUIC stream multiplexing
-
-**API Surface**:
-```typescript
-class QuicCoordinator {
-  async start(): Promise<void>
-  async stop(): Promise<void>
-  async registerAgent(agent: SwarmAgent): Promise<void>
-  async unregisterAgent(agentId: string): Promise<void>
-  async sendMessage(message: SwarmMessage): Promise<void>
-  async broadcast(message: SwarmMessage): Promise<void>
-  async syncState(): Promise<void>
-  async getState(): Promise<SwarmState>
-  getAgentStats(agentId: string): AgentStats | null
-  getAllAgentStats(): Map<string, AgentStats>
-}
-```
-
-**Statistics Tracked**:
-- Total/active agents
-- Total messages
-- Messages per second
-- Average latency per agent
-- QUIC connection statistics
-
-### 2. TransportRouter (`src/swarm/transport-router.ts`)
-
-**Purpose**: Intelligent transport layer with automatic protocol selection and fallback.
-
-**Key Features**:
-- ✅ Protocol selection (QUIC, HTTP/2, auto)
-- ✅ Transparent HTTP/2 fallback on QUIC failure
-- ✅ Connection pooling for both protocols
-- ✅ Per-protocol statistics tracking
-- ✅ Automatic health monitoring
-- ✅ Protocol switching on availability changes
-
-**API Surface**:
-```typescript
-class TransportRouter {
-  async initialize(): Promise<void>
-  async initializeSwarm(swarmId, topology, maxAgents): Promise<QuicCoordinator>
-  async route(message: SwarmMessage, target: SwarmAgent): Promise<RouteResult>
-  getCurrentProtocol(): 'quic' | 'http2'
-  isQuicAvailable(): boolean
-  getStats(protocol?: 'quic' | 'http2'): TransportStats | Map
-  getCoordinator(): QuicCoordinator | undefined
-  async shutdown(): Promise<void>
-}
-```
-
-**Fallback Strategy**:
-1. Attempt QUIC connection
-2. On failure, transparently fallback to HTTP/2
-3. Continue monitoring QUIC availability
-4. Switch back to QUIC when available
-
-### 3. Swarm Integration (`src/swarm/index.ts`)
-
-**Purpose**: High-level API for swarm initialization and management.
-
-**Key Features**:
-- ✅ Single-function swarm initialization
-- ✅ Transport abstraction (hide complexity)
-- ✅ Agent registration/unregistration
-- ✅ Unified statistics interface
-- ✅ Graceful shutdown
-
-**API Surface**:
-```typescript
-async function initSwarm(options: SwarmInitOptions): Promise<SwarmInstance>
-async function checkQuicAvailability(): Promise<boolean>
-
-interface SwarmInstance {
-  swarmId: string
-  topology: SwarmTopology
-  transport: 'quic' | 'http2'
-  coordinator?: QuicCoordinator
-  router: TransportRouter
-  registerAgent(agent: SwarmAgent): Promise<void>
-  unregisterAgent(agentId: string): Promise<void>
-  getStats(): Promise<SwarmStats>
-  shutdown(): Promise<void>
-}
-```
-
-**Configuration Options**:
-```typescript
-interface SwarmInitOptions {
-  swarmId: string
-  topology: 'mesh' | 'hierarchical' | 'ring' | 'star'
-  transport?: 'quic' | 'http2' | 'auto'
-  maxAgents?: number
-  quicPort?: number
-  quicHost?: string
-  enableFallback?: boolean
-}
-```
-
-### 4. MCP Tool Updates (`src/mcp/fastmcp/tools/swarm/init.ts`)
-
-**Enhancements**:
-- ✅ Added `transport` parameter (quic | http2 | auto)
-- ✅ Added `quicPort` parameter
-- ✅ Updated tool description with topology explanations
-- ✅ Backward compatible with existing calls
-
-**New Parameters**:
-```typescript
-{
-  transport: 'quic' | 'http2' | 'auto',  // default: auto
-  quicPort: number                        // default: 4433
-}
-```
-
-## File Structure
-
-```
-agentic-flow/
-├── src/
-│   ├── swarm/
-│   │   ├── quic-coordinator.ts       # NEW: QUIC-enabled coordinator
-│   │   ├── transport-router.ts       # NEW: Protocol selection & routing
-│   │   └── index.ts                  # NEW: High-level swarm API
-│   ├── transport/
-│   │   └── quic.ts                   # UPDATED: Enhanced WASM integration
-│   └── mcp/fastmcp/tools/swarm/
-│       └── init.ts                   # UPDATED: Added transport parameter
-├── tests/swarm/
-│   ├── quic-coordinator.test.ts      # NEW: Coordinator tests (all topologies)
-│   └── transport-router.test.ts      # NEW: Router & fallback tests
-├── examples/
-│   ├── quic-swarm-mesh.ts           # NEW: Mesh topology example
-│   ├── quic-swarm-hierarchical.ts   # NEW: Hierarchical example
-│   └── quic-swarm-auto-fallback.ts  # NEW: Auto-fallback example
-└── docs/
-    ├── architecture/
-    │   ├── QUIC-SWARM-INTEGRATION.md     # NEW: Architecture guide
-    │   └── QUIC-IMPLEMENTATION-SUMMARY.md # NEW: This document
-    └── guides/
-        └── QUIC-SWARM-QUICKSTART.md      # NEW: Quick start guide
-```
-
-## Topology Support
-
-### Mesh Topology
-- **Routing**: Direct peer-to-peer communication
-- **Scalability**: O(n²) connections, best for <20 agents
-- **Use Case**: Maximum redundancy, distributed consensus
-
-### Hierarchical Topology
-- **Routing**: Workers → Coordinators → Workers
-- **Scalability**: O(n) connections, scales to 100+ agents
-- **Use Case**: Centralized task distribution
-
-### Ring Topology
-- **Routing**: Forward to next agent in circular order
-- **Scalability**: O(n) connections, predictable latency
-- **Use Case**: Pipeline processing, token-ring protocols
-
-### Star Topology
-- **Routing**: All messages through central coordinator
-- **Scalability**: O(n) connections, single coordination point
-- **Use Case**: Simple coordination, fan-out/fan-in
-
-## Performance Characteristics
-
-### QUIC Advantages
-- **0-RTT Connection**: Near-instant connection establishment
-- **Stream Multiplexing**: 100+ concurrent streams per connection
-- **No Head-of-Line Blocking**: Independent stream processing
-- **Connection Migration**: Survives network changes (WiFi → Cellular)
-- **QPACK Compression**: Efficient header compression
-
-### Benchmarks (Estimated)
-- **Mesh (5 agents)**: ~10ms avg latency, 1000 msg/s
-- **Mesh (10 agents)**: ~20ms avg latency, 800 msg/s
-- **Hierarchical (50 workers + 5 coordinators)**: ~25ms avg latency, 8000 msg/s
-- **Hierarchical (100 workers + 10 coordinators)**: ~35ms avg latency, 15000 msg/s
-
-## Testing
-
-### Test Coverage
-
-**QuicCoordinator Tests** (`tests/swarm/quic-coordinator.test.ts`):
-- ✅ Mesh topology initialization and agent registration
-- ✅ Hierarchical topology with coordinator-worker routing
-- ✅ Ring topology with circular message forwarding
-- ✅ Star topology with central hub routing
-- ✅ State synchronization across agents
-- ✅ Heartbeat monitoring
-- ✅ Per-agent statistics tracking
-- ✅ Agent registration/unregistration
-- ✅ Max agents limit enforcement
-
-**TransportRouter Tests** (`tests/swarm/transport-router.test.ts`):
-- ✅ QUIC protocol initialization
-- ✅ HTTP/2 protocol initialization
-- ✅ Auto protocol selection
-- ✅ Transparent fallback on QUIC failure
-- ✅ Error handling when fallback disabled
-- ✅ Message routing via QUIC
-- ✅ Message routing via HTTP/2
-- ✅ QUIC statistics tracking
-- ✅ HTTP/2 statistics tracking
-- ✅ Swarm coordinator integration
-
-### Test Commands
-```bash
-# Run all swarm tests
-npm test -- tests/swarm/
-
-# Run coordinator tests only
-npm test -- tests/swarm/quic-coordinator.test.ts
-
-# Run router tests only
-npm test -- tests/swarm/transport-router.test.ts
-```
-
-## Usage Examples
-
-### Basic Mesh Swarm
-```typescript
-import { initSwarm } from 'agentic-flow';
-
-const swarm = await initSwarm({
-  swarmId: 'compute-swarm',
-  topology: 'mesh',
-  transport: 'quic',
-  maxAgents: 5,
-  quicPort: 4433
-});
-
-await swarm.registerAgent({
-  id: 'agent-1',
-  role: 'worker',
-  host: 'localhost',
-  port: 4434,
-  capabilities: ['compute']
-});
-
-const stats = await swarm.getStats();
-await swarm.shutdown();
-```
-
-### Auto Transport with Fallback
-```typescript
-const swarm = await initSwarm({
-  swarmId: 'auto-swarm',
-  topology: 'hierarchical',
-  transport: 'auto',  // Try QUIC, fallback to HTTP/2
-  maxAgents: 20,
-  enableFallback: true
-});
-
-// Router automatically selects best transport
-console.log('Transport:', (await swarm.getStats()).transport);
-```
-
-### MCP Tool Usage
-```typescript
-// Via MCP tool
-mcp__claude-flow__swarm_init({
-  topology: 'mesh',
-  maxAgents: 10,
-  transport: 'quic',
-  quicPort: 4433
-})
-```
-
-## Documentation
-
-### Architecture Documentation
-- **File**: `docs/architecture/QUIC-SWARM-INTEGRATION.md`
-- **Contents**:
-  - System architecture diagrams
-  - Component descriptions
-  - Topology explanations
-  - Message flow diagrams
-  - Performance characteristics
-  - Security considerations
-  - Configuration reference
-  - Migration guide
-
-### Quick Start Guide
-- **File**: `docs/guides/QUIC-SWARM-QUICKSTART.md`
-- **Contents**:
-  - Installation instructions
-  - Basic usage examples
-  - Topology selection guide
-  - Transport configuration
-  - Statistics & monitoring
-  - Common patterns
-  - Troubleshooting
-
-### Implementation Summary
-- **File**: `docs/architecture/QUIC-IMPLEMENTATION-SUMMARY.md`
-- **Contents**: This document
-
-## Integration Points
-
-### QUIC Client Integration
-- Uses existing `QuicClient` from `src/transport/quic.ts`
-- Leverages WASM bindings for QUIC protocol
-- Integrates with `QuicConnectionPool` for connection management
-
-### MCP Integration
-- Updated `swarm_init` tool to accept transport parameter
-- Maintains backward compatibility
-- Enhanced descriptions for better discoverability
-
-### CLI Integration (Future)
-```bash
-# Future CLI commands
-npx agentic-flow swarm init --topology mesh --transport quic --port 4433
-npx agentic-flow swarm status --swarm-id my-swarm
-npx agentic-flow swarm stats --swarm-id my-swarm
-```
-
-## Security Considerations
-
-### TLS 1.3 Encryption
-- All QUIC connections use TLS 1.3
-- Configurable certificate paths
-- Optional peer verification
-
-### Configuration
-```typescript
-{
-  certPath: './certs/cert.pem',
-  keyPath: './certs/key.pem',
-  verifyPeer: true
-}
-```
-
-## Error Handling
-
-### Graceful Degradation
-- QUIC failure → automatic HTTP/2 fallback
-- Connection pool exhaustion → LRU eviction
-- Agent registration failure → clear error messages
-
-### Health Monitoring
-- Periodic QUIC availability checks
-- Automatic protocol switching
-- Statistics-based quality monitoring
-
-## Future Enhancements
-
-### Planned Features
-- [ ] Dynamic topology reconfiguration
-- [ ] Multi-datacenter support
-- [ ] Advanced routing algorithms (shortest path, load-based)
-- [ ] Message priority queues
-- [ ] Encryption at rest for state
-- [ ] WebTransport support
-- [ ] gRPC-over-QUIC integration
-
-### Performance Optimizations
-- [ ] Zero-copy message passing
-- [ ] Custom QPACK dictionaries
-- [ ] Adaptive congestion control
-- [ ] Connection bonding
-- [ ] Stream prioritization
-
-## Migration Guide
-
-### For Existing Users
-
-**Before** (HTTP-only):
-```typescript
-const swarm = await initHttpSwarm({ topology: 'mesh' });
-```
-
-**After** (QUIC-enabled):
-```typescript
-const swarm = await initSwarm({
-  swarmId: 'my-swarm',
-  topology: 'mesh',
-  transport: 'auto'  // Automatic QUIC with HTTP/2 fallback
-});
-```
-
-**Benefits**:
-- 10-50x faster connection establishment (0-RTT)
-- No head-of-line blocking
-- Better mobile network support
-- Transparent HTTP/2 fallback
-
-## Validation Checklist
-
-- ✅ QuicCoordinator implements all topology types
-- ✅ TransportRouter provides transparent fallback
-- ✅ Swarm API is simple and intuitive
-- ✅ MCP tools updated with new parameters
-- ✅ Comprehensive test coverage (all topologies)
-- ✅ Documentation complete (architecture + quick start)
-- ✅ Usage examples for all topologies
-- ✅ Statistics tracking per agent and protocol
-- ✅ Graceful error handling and degradation
-- ✅ Integration with existing QUIC infrastructure
-
-## Dependencies
-
-### Runtime Dependencies
-- `src/transport/quic.ts` - QUIC client/server/pool
-- `src/utils/logger.ts` - Logging infrastructure
-- `src/config/quic.ts` - QUIC configuration
-- `wasm/quic/agentic_flow_quic.js` - WASM bindings
-
-### Development Dependencies
-- `@jest/globals` - Testing framework
-- TypeScript - Type checking
-
-## Breaking Changes
-
-**None** - This is a new feature with backward-compatible MCP tool updates.
-
-## Deployment Considerations
-
-### Network Requirements
-- UDP port open for QUIC (default: 4433)
-- TLS certificates for peer verification (optional)
-- Firewall rules allowing UDP traffic
-
-### Resource Requirements
-- Memory: ~10MB per 100 agents
-- CPU: Minimal overhead (WASM optimized)
-- Network: Bandwidth dependent on message frequency
-
-### Monitoring
-- Track QUIC vs HTTP/2 usage via stats
-- Monitor connection pool utilization
-- Alert on persistent fallback to HTTP/2
-
-## Support
-
-### Resources
-- Architecture Guide: `docs/architecture/QUIC-SWARM-INTEGRATION.md`
-- Quick Start: `docs/guides/QUIC-SWARM-QUICKSTART.md`
-- Examples: `examples/quic-swarm-*.ts`
-- Tests: `tests/swarm/*.test.ts`
-
-### Community
-- GitHub Issues: https://github.com/ruvnet/agentic-flow/issues
-- Documentation: https://github.com/ruvnet/agentic-flow/docs
-
-## Conclusion
-
-The QUIC transport integration provides a high-performance, scalable foundation for multi-agent swarm coordination. With support for 4 topology types, transparent HTTP/2 fallback, and comprehensive statistics tracking, it enables efficient agent-to-agent communication at scale.
-
-**Key Achievements**:
-- ✅ Complete QUIC transport integration
-- ✅ 4 topology types supported (mesh, hierarchical, ring, star)
-- ✅ Transparent fallback mechanism
-- ✅ Per-agent statistics tracking
-- ✅ Comprehensive test coverage
-- ✅ Full documentation suite
-- ✅ Production-ready error handling
-
-**Next Steps**:
-1. Run integration tests
-2. Benchmark performance across topologies
-3. Deploy to staging environment
-4. Monitor QUIC usage statistics
-5. Gather user feedback
-6. Plan advanced features (dynamic reconfiguration, multi-DC support)