Merge pull request #1 from LOUSTA79/codex/update-dependencies-to-latest-versions

Add two-agent production system with monitoring

Author: LOUSTA79

Tool/two-agent-production-system/README.md

@@ -0,0 +1,34 @@
+# Two-Agent Production System
+
+A production-ready orchestration harness that coordinates planning and execution agents with real-time monitoring. Built for LOUSTA using Claude via the official Anthropic SDK.
+
+## Features
+
+- Planner and executor agents with graceful offline fallbacks.
+- Central orchestrator that tracks performance metrics for every step.
+- WebSocket-enabled monitoring dashboard (`npm run monitor`).
+- Deterministic integration tests that validate the offline execution path.
+
+## Getting Started
+
+```bash
+npm install
+npm run dev "Ship the next iteration of the monitoring dashboard"
+```
+
+Set an Anthropic API key to enable live model calls:
+
+```bash
+export ANTHROPIC_API_KEY="sk-ant-..."
+npm start "Deploy production workflow"
+```
+
+The monitoring dashboard is served on [http://localhost:3050](http://localhost:3050) by default and exposes a `/metrics` endpoint plus a WebSocket feed at `/ws`.
+
+Run the included smoke test:
+
+```bash
+npm test
+```
+
+This executes the orchestrator with simulated agents, ensuring the core workflow remains stable.

Tool/two-agent-production-system/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "two-agent-production-system",
+  "version": "2.0.0",
+  "description": "Production Two-Agent System with Real-Time Monitoring - Built for LOUSTA",
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js",
+    "monitor": "node src/monitoring/dashboard-server.js",
+    "dev": "node --watch src/index.js",
+    "test": "node tests/test-agents.js"
+  },
+  "keywords": ["ai", "agents", "anthropic", "claude", "automation", "orchestration"],
+  "author": "LOUSTA <lousta79@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.0",
+    "express": "^4.18.2",
+    "ws": "^8.16.0",
+    "dotenv": "^16.4.1",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "cli-table3": "^0.6.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

Tool/two-agent-production-system/src/agents/baseAgent.js

@@ -0,0 +1,58 @@
+import { Anthropic } from '@anthropic-ai/sdk';
+import EventEmitter from 'node:events';
+
+export default class BaseAgent extends EventEmitter {
+  constructor({ name, systemPrompt, metrics, model = 'claude-3-5-sonnet-20241022', maxTokens = 1024 }) {
+    super();
+    this.name = name;
+    this.systemPrompt = systemPrompt;
+    this.metrics = metrics;
+    this.model = model;
+    this.maxTokens = maxTokens;
+    this.apiKey = process.env.ANTHROPIC_API_KEY;
+    this.client = this.apiKey ? new Anthropic({ apiKey: this.apiKey }) : null;
+    this.online = Boolean(this.client);
+  }
+
+  async sendMessage({ prompt, context = [] }) {
+    this.metrics?.increment(`${this.name}:requests`);
+
+    if (!this.online) {
+      const simulated = await this.simulateResponse({ prompt, context });
+      this.emit('message', { prompt, response: simulated, offline: true });
+      return { text: simulated, offline: true };
+    }
+
+    try {
+      const response = await this.client.messages.create({
+        model: this.model,
+        max_tokens: this.maxTokens,
+        system: this.systemPrompt,
+        messages: [
+          ...context,
+          { role: 'user', content: prompt },
+        ],
+      });
+
+      const text = response.content
+        ?.map((fragment) => fragment.text ?? '')
+        .join('')
+        .trim();
+
+      const payload = { text, raw: response, offline: false };
+      this.emit('message', { prompt, response: payload });
+      return payload;
+    } catch (error) {
+      this.metrics?.increment(`${this.name}:fallbacks`);
+      const simulated = await this.simulateResponse({ prompt, context, error });
+      const payload = { text: simulated, offline: true, error };
+      this.emit('message', { prompt, response: payload, error });
+      return payload;
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async simulateResponse() {
+    return 'Simulation not implemented.';
+  }
+}

Tool/two-agent-production-system/src/agents/executorAgent.js

@@ -0,0 +1,50 @@
+import BaseAgent from './baseAgent.js';
+
+export default class ExecutorAgent extends BaseAgent {
+  constructor(options = {}) {
+    super({
+      name: options.name ?? 'executor',
+      systemPrompt:
+        options.systemPrompt ??
+        'You are an implementation specialist that executes planned steps with precision and returns concise status updates.',
+      metrics: options.metrics,
+      model: options.model,
+      maxTokens: options.maxTokens ?? 1024,
+    });
+  }
+
+  async executeStep(step, context = []) {
+    this.metrics?.increment('executor:steps');
+
+    if (!this.online) {
+      return this.offlineExecution(step);
+    }
+
+    const response = await this.sendMessage({
+      prompt: `You are executing step #${step.id}: ${step.description}.\nProvide a short status update and outline any outputs or follow-up actions.`,
+      context,
+    });
+
+    if (response.offline) {
+      return this.offlineExecution(step);
+    }
+
+    return {
+      id: step.id,
+      status: 'completed',
+      detail: response.text,
+    };
+  }
+
+  offlineExecution(step) {
+    return {
+      id: step.id,
+      status: 'completed',
+      detail: `Simulated completion for step #${step.id}: ${step.description}`,
+    };
+  }
+
+  async simulateResponse({ prompt }) {
+    return `Simulated execution response for prompt: ${prompt}`;
+  }
+}

Tool/two-agent-production-system/src/agents/plannerAgent.js

@@ -0,0 +1,75 @@
+import BaseAgent from './baseAgent.js';
+
+export default class PlannerAgent extends BaseAgent {
+  constructor(options = {}) {
+    super({
+      name: options.name ?? 'planner',
+      systemPrompt:
+        options.systemPrompt ??
+        'You are a senior technical planner that breaks high level goals into concise, actionable steps.',
+      metrics: options.metrics,
+      model: options.model,
+      maxTokens: options.maxTokens ?? 2048,
+    });
+  }
+
+  async plan(goal, context = []) {
+    this.metrics?.increment('planner:plans');
+
+    if (!this.online) {
+      return this.offlinePlan(goal);
+    }
+
+    const response = await this.sendMessage({
+      prompt: `Create a numbered execution plan for the following goal. Keep each step concise.\nGoal: ${goal}`,
+      context,
+    });
+
+    if (response.offline) {
+      return this.offlinePlan(goal);
+    }
+
+    const steps = this.parsePlan(response.text);
+    if (steps.length === 0) {
+      return this.offlinePlan(goal);
+    }
+
+    return steps;
+  }
+
+  parsePlan(text = '') {
+    return text
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line, index) => ({
+        id: index + 1,
+        description: line.replace(/^[0-9]+[).\-\s]*/, ''),
+        rationale: 'Provided by planner',
+      }));
+  }
+
+  offlinePlan(goal) {
+    return [
+      {
+        id: 1,
+        description: `Understand the goal: ${goal}`,
+        rationale: 'Establish context and success criteria.',
+      },
+      {
+        id: 2,
+        description: 'Design an execution strategy with monitoring hooks.',
+        rationale: 'Ensure each step can be observed in production.',
+      },
+      {
+        id: 3,
+        description: 'Execute and verify results iteratively.',
+        rationale: 'Guarantee high quality output.',
+      },
+    ];
+  }
+
+  async simulateResponse({ prompt }) {
+    return `Simulated plan for prompt: ${prompt}`;
+  }
+}

Tool/two-agent-production-system/src/index.js

@@ -0,0 +1,40 @@
+import 'dotenv/config';
+import chalk from 'chalk';
+import ora from 'ora';
+import PlannerAgent from './agents/plannerAgent.js';
+import ExecutorAgent from './agents/executorAgent.js';
+import Orchestrator from './orchestration/orchestrator.js';
+import Metrics from './monitoring/metrics.js';
+import { startDashboardServer } from './monitoring/dashboard-server.js';
+
+const goal = process.argv.slice(2).join(' ') || 'Deliver a production-ready two-agent workflow with monitoring.';
+
+async function main() {
+  const metrics = new Metrics();
+  const planner = new PlannerAgent({ metrics });
+  const executor = new ExecutorAgent({ metrics });
+
+  const orchestrator = new Orchestrator({ planner, executor, metrics });
+  startDashboardServer(metrics);
+
+  const spinner = ora('Coordinating agents...').start();
+  try {
+    const result = await orchestrator.run(goal);
+    spinner.succeed('Agents finished execution.');
+
+    console.log(chalk.green('\nSummary:'));
+    for (const outcome of result.results) {
+      console.log(` - Step #${outcome.id}: ${outcome.status} (${Math.round(outcome.durationMs)}ms)`);
+      console.log(`   Detail: ${outcome.detail}`);
+    }
+
+    console.log(chalk.bold(`\nGoal: ${goal}`));
+    console.log(chalk.bold('Status: Completed'));
+  } catch (error) {
+    spinner.fail('Agent orchestration failed.');
+    console.error(chalk.red(error.stack || error.message));
+    process.exitCode = 1;
+  }
+}
+
+main();

Tool/two-agent-production-system/src/monitoring/dashboard-server.js

@@ -0,0 +1,48 @@
+import http from 'node:http';
+import express from 'express';
+import chalk from 'chalk';
+import { WebSocketServer } from 'ws';
+import Metrics from './metrics.js';
+
+const DEFAULT_PORT = Number.parseInt(process.env.MONITOR_PORT ?? '3050', 10);
+
+export function startDashboardServer(metricsInstance = new Metrics(), options = {}) {
+  const port = options.port ?? DEFAULT_PORT;
+  const metrics = metricsInstance;
+
+  const app = express();
+  app.get('/metrics', (_req, res) => {
+    res.json(metrics.snapshot());
+  });
+
+  const server = http.createServer(app);
+  const wss = new WebSocketServer({ server, path: '/ws' });
+
+  wss.on('connection', (socket) => {
+    socket.send(JSON.stringify({ type: 'snapshot', data: metrics.snapshot() }));
+
+    const handler = (snapshot) => {
+      if (socket.readyState === socket.OPEN) {
+        socket.send(JSON.stringify({ type: 'update', data: snapshot }));
+      }
+    };
+
+    metrics.on('update', handler);
+
+    socket.on('close', () => {
+      metrics.off('update', handler);
+    });
+  });
+
+  server.listen(port, () => {
+    console.log(chalk.green(`📊 Monitoring dashboard available at http://localhost:${port}`));
+  });
+
+  return { app, server, wss };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const metrics = new Metrics();
+  startDashboardServer(metrics);
+  console.log(chalk.blue('Standalone monitoring server started. Waiting for metrics...'));
+}

Tool/two-agent-production-system/src/monitoring/metrics.js

@@ -0,0 +1,39 @@
+import EventEmitter from 'node:events';
+
+export default class Metrics extends EventEmitter {
+  constructor() {
+    super();
+    this.counters = new Map();
+    this.gauges = new Map();
+    this.timings = [];
+  }
+
+  increment(name, value = 1) {
+    const newValue = (this.counters.get(name) ?? 0) + value;
+    this.counters.set(name, newValue);
+    this.emit('update', this.snapshot());
+    return newValue;
+  }
+
+  setGauge(name, value) {
+    this.gauges.set(name, value);
+    this.emit('update', this.snapshot());
+  }
+
+  timing(name, value) {
+    this.timings.push({ name, value, at: new Date().toISOString() });
+    if (this.timings.length > 50) {
+      this.timings.shift();
+    }
+    this.emit('update', this.snapshot());
+  }
+
+  snapshot() {
+    return {
+      counters: Object.fromEntries(this.counters),
+      gauges: Object.fromEntries(this.gauges),
+      timings: [...this.timings],
+      timestamp: new Date().toISOString(),
+    };
+  }
+}