npm - agentic-flow - Versions diffs - 1.9.0 → 1.9.2 - Mend

agentic-flow 1.9.0 → 1.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1223) hide show

package/agentic-flow/docker/federation-test/README.md DELETED Viewed

@@ -1,314 +0,0 @@
-# Federation Multi-Agent Collaboration Test
-## Overview
-This test simulates **5 agents collaborating** through a shared **Federation Hub** using Docker containers. It validates:
-- ✅ Multi-agent memory sharing
-- ✅ Tenant isolation
-- ✅ Real-time synchronization
-- ✅ WebSocket-based communication
-- ✅ Episode storage and retrieval
-## Architecture
-```
-┌─────────────────────────────────────────────────────┐
-│                  Federation Hub                     │
-│              (WebSocket Server)                     │
-│            Port: 8443                               │
-└────────────┬────────────────────────────────────────┘
-             │
-      ┌──────┴──────┬──────────┬──────────┬──────────┐
-      │             │          │          │          │
-┌─────▼────┐  ┌────▼─────┐ ┌──▼──────┐ ┌▼─────────┐ ┌▼──────────┐
-│Researcher│  │  Coder   │ │ Tester  │ │ Reviewer │ │  Isolated │
-│  Agent   │  │  Agent   │ │  Agent  │ │  Agent   │ │   Agent   │
-└──────────┘  └──────────┘ └─────────┘ └──────────┘ └───────────┘
-   Tenant: test-collaboration              Tenant: different-tenant
-```
-## Components
-### 1. Federation Hub (`federation-hub`)
-- **Role**: Central memory synchronization server
-- **Port**: 8443 (WebSocket)
-- **Database**: SQLite at `/data/hub.db`
-- **Features**:
-  - Tenant-isolated episode storage
-  - Vector clock sync
-  - Change log tracking
-  - Real-time broadcasting
-### 2. Researcher Agent (`agent-researcher`)
-- **Role**: Find patterns and insights
-- **Task**: Analyze codebase for collaboration opportunities
-- **Output**: Pattern analysis reports
-### 3. Coder Agent (`agent-coder`)
-- **Role**: Implement solutions
-- **Task**: Build features based on researcher findings
-- **Output**: Code implementations
-### 4. Tester Agent (`agent-tester`)
-- **Role**: Validate work
-- **Task**: Test implementations
-- **Output**: Test results and coverage reports
-### 5. Reviewer Agent (`agent-reviewer`)
-- **Role**: Quality assurance
-- **Task**: Review code quality and security
-- **Output**: Quality reports and recommendations
-### 6. Isolated Agent (`agent-isolated`)
-- **Role**: Tenant isolation validation
-- **Tenant**: `different-tenant` (separate from others)
-- **Expected**: Cannot access other tenant's memories
-### 7. Monitor Dashboard (`monitor`)
-- **Role**: Real-time visualization
-- **Port**: 3000 (HTTP)
-- **URL**: http://localhost:3000
-- **Features**:
-  - Connected agents count
-  - Total episodes stored
-  - Active tenants
-  - Real-time activity log
-## Running the Test
-### Quick Start
-```bash
-cd docker/federation-test
-./run-test.sh
-```
-### Manual Steps
-```bash
-# 1. Build project
-npm run build
-# 2. Build Docker images
-cd docker/federation-test
-docker-compose build
-# 3. Start all services
-docker-compose up
-# 4. Open monitor dashboard
-open http://localhost:3000
-# 5. Stop test (Ctrl+C)
-docker-compose down
-```
-## Expected Test Flow
-### Phase 1: Connection (0-10s)
-```
-[Hub] Federation Hub Server started on port 8443
-[Hub] Agent authenticated: researcher-001 (tenant: test-collaboration)
-[Hub] Agent authenticated: coder-001 (tenant: test-collaboration)
-[Hub] Agent authenticated: tester-001 (tenant: test-collaboration)
-[Hub] Agent authenticated: reviewer-001 (tenant: test-collaboration)
-[Hub] Agent authenticated: isolated-001 (tenant: different-tenant)
-```
-### Phase 2: Collaboration (10-60s)
-```
-[researcher] Iteration 1: Identified optimal async/await patterns (reward: 0.87)
-[coder] Iteration 1: Implemented async data fetcher (reward: 0.92)
-[tester] Iteration 1: Unit tests: 45 passed (reward: 0.88)
-[reviewer] Iteration 1: Code quality: A+ (reward: 0.94)
-[isolated] Iteration 1: Found performance bottleneck (reward: 0.79)
-```
-### Phase 3: Memory Sharing
-```
-[Hub] Push completed: researcher-001 (1 episodes)
-[Hub] Pull completed: coder-001 (1 episodes from researcher)
-[Hub] Push completed: coder-001 (1 episodes)
-[Hub] Pull completed: tester-001 (2 episodes from researcher+coder)
-```
-### Phase 4: Tenant Isolation Validation
-```
-[Hub] Tenant stats: test-collaboration (4 agents, 40 episodes)
-[Hub] Tenant stats: different-tenant (1 agent, 10 episodes)
-✓ No cross-tenant data leakage detected
-```
-## Validation Checklist
-After running the test, verify:
-- [ ] All 5 agents connected successfully
-- [ ] Hub reports 2 distinct tenants
-- [ ] `test-collaboration` tenant has 4 agents
-- [ ] `different-tenant` has 1 agent
-- [ ] Episodes stored in hub database
-- [ ] No cross-tenant data access
-- [ ] Monitor dashboard shows real-time updates
-- [ ] Agents complete 10-12 iterations each
-- [ ] Average reward > 0.75 for all agents
-- [ ] No connection errors or timeouts
-## Inspecting Results
-### View Hub Database
-```bash
-# Access hub container
-docker exec -it federation-hub sh
-# Query database
-sqlite3 /data/hub.db
-# Check episodes
-SELECT COUNT(*), tenant_id FROM episodes GROUP BY tenant_id;
-# Check agents
-SELECT * FROM agents;
-# Exit
-.exit
-```
-### View Agent Logs
-```bash
-# Researcher
-docker logs agent-researcher
-# Coder
-docker logs agent-coder
-# Tester
-docker logs agent-tester
-# Reviewer
-docker logs agent-reviewer
-# Isolated
-docker logs agent-isolated
-```
-### Monitor Hub Stats
-```bash
-# Via HTTP endpoint
-curl http://localhost:8444/stats
-# Expected output:
-{
-  "connectedAgents": 5,
-  "totalEpisodes": 50,
-  "tenants": 2,
-  "uptime": 60
-}
-```
-## Performance Metrics
-### Expected Latencies
-- **Agent connection**: <100ms
-- **Authentication**: <50ms
-- **Memory sync (pull)**: <50ms
-- **Memory sync (push)**: <100ms
-- **Episode storage**: <20ms
-### Expected Throughput
-- **Sync rate**: 1 sync/5s per agent (0.2 Hz)
-- **Total syncs**: ~60 syncs over 60s test
-- **Episodes**: 50-60 total (10-12 per agent)
-## Troubleshooting
-### Hub Not Starting
-```bash
-# Check port 8443 is available
-lsof -i :8443
-# View hub logs
-docker logs federation-hub
-```
-### Agents Not Connecting
-```bash
-# Check network connectivity
-docker network inspect federation-test_federation-network
-# Verify hub is ready
-curl http://localhost:8444/health
-```
-### Database Issues
-```bash
-# Reset hub database
-docker-compose down -v
-docker-compose up
-```
-## Clean Up
-```bash
-# Stop all containers
-docker-compose down
-# Remove volumes (reset database)
-docker-compose down -v
-# Remove images
-docker-compose down --rmi all
-```
-## Success Criteria
-The test is considered **successful** if:
-1. ✅ All 5 agents connect to hub within 10 seconds
-2. ✅ Agents complete at least 10 iterations each
-3. ✅ Hub stores 50+ episodes total
-4. ✅ `test-collaboration` tenant has 40+ episodes
-5. ✅ `different-tenant` has 10+ episodes (isolated)
-6. ✅ No cross-tenant data access detected
-7. ✅ Average sync latency <100ms
-8. ✅ No connection errors or failures
-9. ✅ Monitor dashboard shows real-time updates
-10. ✅ All agents disconnect gracefully
-## Next Steps
-After successful test:
-1. **Scale Test**: Increase to 10, 50, 100 agents
-2. **Load Test**: Simulate high-frequency syncs
-3. **Failure Test**: Test hub recovery and agent reconnection
-4. **Multi-Region**: Deploy hubs in different regions
-5. **Production**: Deploy to Kubernetes with real AgentDB
-## Files
-```
-docker/federation-test/
-├── README.md                    # This file
-├── docker-compose.yml           # Service orchestration
-├── Dockerfile.hub              # Hub server image
-├── Dockerfile.agent            # Agent image
-├── Dockerfile.monitor          # Monitor dashboard image
-├── run-hub.ts                  # Hub server entrypoint
-├── run-agent.ts                # Agent entrypoint
-├── run-monitor.ts              # Monitor entrypoint
-└── run-test.sh                 # Test execution script
-```
----
-**Built with ❤️ by [@ruvnet](https://github.com/ruvnet)**
-**Test Duration**: ~60 seconds
-**Agents**: 5 concurrent
-**Shared Memories**: 50+ episodes
-**Tenant Isolation**: Verified

package/agentic-flow/docker/federation-test/run-test.sh DELETED Viewed

@@ -1,65 +0,0 @@
-#!/bin/bash
-# Federation Multi-Agent Collaboration Test
-# This script runs a complete Docker-based test of the federated memory system
-set -e
-echo "🚀 Federation Multi-Agent Collaboration Test"
-echo "=============================================="
-echo ""
-# Colors
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-# Check if Docker is running
-if ! docker info > /dev/null 2>&1; then
-    echo "❌ Docker is not running. Please start Docker and try again."
-    exit 1
-fi
-echo -e "${BLUE}📦 Building project...${NC}"
-cd ../..
-npm run build
-cd docker/federation-test
-echo ""
-echo -e "${BLUE}🏗️  Building Docker images...${NC}"
-docker-compose build
-echo ""
-echo -e "${GREEN}✅ Build complete!${NC}"
-echo ""
-echo -e "${YELLOW}Starting federation test...${NC}"
-echo ""
-echo "Test scenario:"
-echo "  • 1 Federation Hub (shared memory server)"
-echo "  • 4 Collaborative Agents (test-collaboration tenant):"
-echo "    - Researcher: Finds patterns"
-echo "    - Coder: Implements solutions"
-echo "    - Tester: Validates work"
-echo "    - Reviewer: Quality checks"
-echo "  • 1 Isolated Agent (different-tenant tenant)"
-echo "  • 1 Monitor Dashboard (http://localhost:3000)"
-echo ""
-echo "Expected behavior:"
-echo "  ✓ All agents connect to hub"
-echo "  ✓ Agents share memories within same tenant"
-echo "  ✓ Isolated agent cannot access other tenant's memories"
-echo "  ✓ Real-time sync <100ms"
-echo "  ✓ Memory persists across agent lifecycles"
-echo ""
-echo -e "${BLUE}Press Ctrl+C to stop the test${NC}"
-echo ""
-# Start services
-docker-compose up --remove-orphans
-# Cleanup on exit
-trap "docker-compose down -v" EXIT
-echo ""
-echo -e "${GREEN}✅ Test complete!${NC}"

package/agentic-flow/docker/federation-test/standalone-agent.js DELETED Viewed

@@ -1,180 +0,0 @@
-/**
- * Standalone Agent for Docker
- * Uses built npm package
- */
-import { FederationHubClient } from '../../dist/federation/FederationHubClient.js';
-import { SecurityManager } from '../../dist/federation/SecurityManager.js';
-const AGENT_TYPE = process.env.AGENT_TYPE || 'researcher';
-const AGENT_ID = process.env.AGENT_ID || `${AGENT_TYPE}-${Date.now()}`;
-const TENANT_ID = process.env.TENANT_ID || 'test-collaboration';
-const HUB_ENDPOINT = process.env.HUB_ENDPOINT || 'ws://federation-hub:8443';
-class CollaborativeAgent {
-  constructor(agentId, agentType, tenantId, hubEndpoint) {
-    this.agentId = agentId;
-    this.agentType = agentType;
-    this.tenantId = tenantId;
-    this.hubEndpoint = hubEndpoint;
-    this.security = new SecurityManager();
-    this.episodes = [];
-    this.iteration = 0;
-  }
-  async initialize() {
-    console.log(`\n🤖 Initializing ${this.agentType} agent: ${this.agentId}`);
-    console.log(`   Tenant: ${this.tenantId}`);
-    console.log(`   Hub: ${this.hubEndpoint}`);
-    // Create authentication token
-    const token = await this.security.createAgentToken({
-      agentId: this.agentId,
-      tenantId: this.tenantId,
-      expiresAt: Date.now() + 300000 // 5 minutes
-    });
-    // Create hub client
-    this.client = new FederationHubClient({
-      endpoint: this.hubEndpoint,
-      agentId: this.agentId,
-      tenantId: this.tenantId,
-      token
-    });
-    // Connect to hub
-    await this.client.connect();
-    console.log(`✅ Connected to federation hub\n`);
-  }
-  async collaborate() {
-    console.log(`🚀 Starting collaboration loop...\n`);
-    // Run collaboration for 60 seconds
-    const endTime = Date.now() + 60000;
-    while (Date.now() < endTime) {
-      this.iteration++;
-      try {
-        // Execute agent-specific task
-        const episode = await this.executeTask();
-        this.episodes.push(episode);
-        // Sync with hub
-        await this.syncWithHub();
-        console.log(`[${this.agentType}] Iteration ${this.iteration} complete (reward: ${episode.reward.toFixed(2)})`);
-        // Wait before next iteration
-        await new Promise(resolve => setTimeout(resolve, 5000));
-      } catch (error) {
-        console.error(`[${this.agentType}] Error:`, error.message);
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
-    }
-    console.log(`\n✅ Collaboration complete!`);
-    this.printSummary();
-  }
-  async executeTask() {
-    const startTime = Date.now();
-    let task, output, reward, critique;
-    switch (this.agentType) {
-      case 'researcher':
-        task = 'research-patterns';
-        output = ['Optimal async patterns', 'Performance bottlenecks', 'Reusable structures'][Math.floor(Math.random() * 3)];
-        reward = 0.75 + Math.random() * 0.2;
-        critique = 'Found collaboration patterns';
-        break;
-      case 'coder':
-        task = 'implement-solution';
-        output = ['Async fetcher with retry', 'Validation middleware', 'Caching layer'][Math.floor(Math.random() * 3)];
-        reward = 0.80 + Math.random() * 0.15;
-        critique = 'Code follows best practices';
-        break;
-      case 'tester':
-        task = 'validate-work';
-        output = ['Unit tests: 45 passed', 'Integration: 12 passed', 'E2E: 8 passed'][Math.floor(Math.random() * 3)];
-        reward = 0.85 + Math.random() * 0.1;
-        critique = 'Tests passed, learned from failures';
-        break;
-      case 'reviewer':
-        task = 'quality-check';
-        output = ['Quality: A+', 'Security: No issues', 'Performance: Good'][Math.floor(Math.random() * 3)];
-        reward = 0.90 + Math.random() * 0.05;
-        critique = 'Quality improved from team learning';
-        break;
-      default:
-        task = 'generic-task';
-        output = 'Task completed';
-        reward = 0.7 + Math.random() * 0.25;
-        critique = 'Completed successfully';
-    }
-    const latencyMs = Date.now() - startTime;
-    return {
-      sessionId: this.agentId,
-      task,
-      input: `Execute task ${this.iteration}`,
-      output,
-      reward,
-      critique,
-      success: reward >= 0.7,
-      tokensUsed: Math.floor(Math.random() * 1000) + 500,
-      latencyMs
-    };
-  }
-  async syncWithHub() {
-    await this.client.sync({});
-  }
-  printSummary() {
-    const avgReward = this.episodes.reduce((sum, e) => sum + e.reward, 0) / this.episodes.length;
-    const successRate = this.episodes.filter(e => e.success).length / this.episodes.length;
-    console.log(`\n📊 Agent Summary:`);
-    console.log(`   Type: ${this.agentType}`);
-    console.log(`   ID: ${this.agentId}`);
-    console.log(`   Iterations: ${this.iteration}`);
-    console.log(`   Average Reward: ${avgReward.toFixed(3)}`);
-    console.log(`   Success Rate: ${(successRate * 100).toFixed(1)}%`);
-  }
-  async cleanup() {
-    console.log(`\n🧹 Cleaning up agent...`);
-    await this.client.disconnect();
-    console.log(`✅ Agent disconnected`);
-  }
-}
-async function main() {
-  const agent = new CollaborativeAgent(
-    AGENT_ID,
-    AGENT_TYPE,
-    TENANT_ID,
-    HUB_ENDPOINT
-  );
-  try {
-    await agent.initialize();
-    await agent.collaborate();
-  } catch (error) {
-    console.error('Agent failed:', error);
-    process.exit(1);
-  } finally {
-    await agent.cleanup();
-  }
-}
-main();

package/agentic-flow/docker/federation-test/standalone-hub.js DELETED Viewed

@@ -1,85 +0,0 @@
-/**
- * Standalone Federation Hub Server for Docker
- * Uses built npm package
- */
-import { FederationHubServer } from '../../dist/federation/FederationHubServer.js';
-import express from 'express';
-const PORT = parseInt(process.env.FEDERATION_HUB_PORT || process.env.HUB_PORT || '8443');
-const DB_PATH = process.env.FEDERATION_DB_PATH || process.env.HUB_DB_PATH || '/data/hub.db';
-const MAX_AGENTS = parseInt(process.env.FEDERATION_MAX_AGENTS || '1000');
-async function main() {
-  console.log('\n🌐 Starting Federation Hub Server...');
-  console.log('═'.repeat(60));
-  console.log(`📍 Port: ${PORT}`);
-  console.log(`💾 Database: ${DB_PATH}`);
-  console.log(`👥 Max Agents: ${MAX_AGENTS}`);
-  console.log('🔒 Protocol: WebSocket (QUIC support planned)');
-  console.log('');
-  try {
-    // Create hub server
-    const hub = new FederationHubServer({
-      port: PORT,
-      dbPath: DB_PATH,
-      maxAgents: MAX_AGENTS,
-      syncInterval: 5000
-    });
-    // Start hub
-    await hub.start();
-    // Create health check endpoint
-    const app = express();
-    const healthPort = 8444;
-    app.get('/health', (req, res) => {
-      const stats = hub.getStats();
-      res.json({
-        status: 'healthy',
-        ...stats,
-        timestamp: Date.now()
-      });
-    });
-    app.get('/stats', (req, res) => {
-      const stats = hub.getStats();
-      res.json(stats);
-    });
-    app.listen(healthPort, () => {
-      console.log(`✅ Health check server running on port ${healthPort}`);
-    });
-    console.log('✅ Federation Hub Server is ready!');
-    console.log('═'.repeat(60));
-    console.log('');
-    // Graceful shutdown
-    process.on('SIGTERM', async () => {
-      console.log('\n🛑 Shutting down...');
-      await hub.stop();
-      process.exit(0);
-    });
-    process.on('SIGINT', async () => {
-      console.log('\n🛑 Shutting down...');
-      await hub.stop();
-      process.exit(0);
-    });
-    // Keep alive and log stats
-    setInterval(() => {
-      const stats = hub.getStats();
-      console.log(`[Hub] Agents: ${stats.connectedAgents}, Episodes: ${stats.totalEpisodes}, Tenants: ${stats.tenants}`);
-    }, 10000);
-  } catch (error) {
-    console.error('❌ Hub server failed:', error);
-    process.exit(1);
-  }
-}
-main();

package/agentic-flow/docker/federation-test/test-published-hub.js DELETED Viewed

@@ -1,66 +0,0 @@
-import { FederationHubServer } from 'agentic-flow/dist/federation/FederationHubServer.js';
-import express from 'express';
-const PORT = parseInt(process.env.FEDERATION_HUB_PORT || '8443');
-const DB_PATH = process.env.FEDERATION_DB_PATH || '/data/hub.db';
-async function main() {
-  console.log('\n🌐 Testing Published Package v1.8.13...');
-  console.log('═'.repeat(60));
-  console.log(`📍 Port: ${PORT}`);
-  console.log(`💾 Database: ${DB_PATH}`);
-  console.log('');
-  try {
-    const hub = new FederationHubServer({
-      port: PORT,
-      dbPath: DB_PATH,
-      maxAgents: 100,
-      syncInterval: 5000
-    });
-    await hub.start();
-    const app = express();
-    const healthPort = 8444;
-    app.get('/health', (req, res) => {
-      const stats = hub.getStats();
-      res.json({ status: 'healthy', ...stats, timestamp: Date.now() });
-    });
-    app.get('/stats', (req, res) => {
-      res.json(hub.getStats());
-    });
-    app.listen(healthPort, () => {
-      console.log(`✅ Health check server running on port ${healthPort}`);
-    });
-    console.log('✅ Published package working correctly!');
-    console.log('═'.repeat(60));
-    setInterval(() => {
-      const stats = hub.getStats();
-      console.log(`[Hub] Agents: ${stats.connectedAgents}, Episodes: ${stats.totalEpisodes}`);
-    }, 10000);
-    process.on('SIGTERM', async () => {
-      console.log('\n🛑 Shutting down...');
-      await hub.stop();
-      process.exit(0);
-    });
-    process.on('SIGINT', async () => {
-      console.log('\n🛑 Shutting down...');
-      await hub.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    console.error('❌ Test failed:', error);
-    console.error(error.stack);
-    process.exit(1);
-  }
-}
-main();

package/agentic-flow/docker/test-instance/.claude-flow/metrics/agent-metrics.json DELETED Viewed

	@@ -1 +0,0 @@
1	- {}