@louloulinx/metagpt 0.1.3

package/src/workflow/executors/sequence-executor.ts

@@ -0,0 +1,196 @@
+import type { NodeExecutor, WorkflowNode } from '../../types/workflow';
+
+/**
+ * 顺序节点配置
+ */
+interface SequenceConfig {
+  /** 错误处理策略 */
+  errorStrategy?: 'fail-fast' | 'continue' | 'ignore';
+  /** 超时时间(ms) */
+  timeout?: number;
+  /** 是否传递上一个节点的结果到下一个节点 */
+  passPreviousResult?: boolean;
+}
+
+/**
+ * 顺序节点执行器
+ * 用于按顺序执行多个子节点
+ */
+export class SequenceNodeExecutor implements NodeExecutor {
+  private status: string = 'pending';
+  private result: any = null;
+
+  /**
+   * 执行顺序节点
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  async execute(node: WorkflowNode, context: any): Promise<any[]> {
+    try {
+      this.status = 'running';
+      
+      // 获取顺序配置
+      const config = this.getSequenceConfig(node);
+      
+      // 获取子节点执行器
+      const childExecutors = this.getChildExecutors(node, context);
+      if (childExecutors.length === 0) {
+        throw new Error(`No child nodes found in sequence node: ${node.id}`);
+      }
+
+      // 执行子节点
+      const results = await this.executeSequence(childExecutors, config, context);
+      this.result = results;
+      this.status = 'completed';
+      
+      return results;
+    } catch (error) {
+      this.status = 'failed';
+      this.result = error;
+      throw error;
+    }
+  }
+
+  /**
+   * 验证节点配置
+   * @param node 工作流节点
+   */
+  validate(node: WorkflowNode): boolean {
+    return (
+      node.type === 'sequence' &&
+      Array.isArray(node.childIds) &&
+      node.childIds.length > 0
+    );
+  }
+
+  /**
+   * 获取节点状态
+   */
+  getStatus(): string {
+    return this.status;
+  }
+
+  /**
+   * 获取执行结果
+   */
+  getResult(): any {
+    return this.result;
+  }
+
+  /**
+   * 从节点配置中获取顺序配置
+   * @param node 工作流节点
+   */
+  private getSequenceConfig(node: WorkflowNode): SequenceConfig {
+    return {
+      errorStrategy: 'fail-fast',
+      timeout: 0,
+      passPreviousResult: false,
+      ...(node.config?.sequence || {}),
+    };
+  }
+
+  /**
+   * 获取子节点执行器列表
+   * @param node 工作流节点
+   * @param context 执行上下文
+   */
+  private getChildExecutors(
+    node: WorkflowNode,
+    context: any
+  ): Array<(ctx: any) => Promise<any>> {
+    return node.childIds.map(childId => {
+      const childNode = context.workflow.nodes.find(
+        (n: WorkflowNode) => n.id === childId
+      );
+      if (!childNode) {
+        throw new Error(`Child node not found: ${childId}`);
+      }
+
+      const executor = context.workflow.nodeExecutors.get(childNode.type);
+      if (!executor) {
+        throw new Error(`No executor found for node type: ${childNode.type}`);
+      }
+
+      return (ctx: any) => executor.execute(childNode, ctx);
+    });
+  }
+
+  /**
+   * 顺序执行子节点
+   * @param executors 执行器列表
+   * @param config 顺序配置
+   * @param baseContext 基础上下文
+   */
+  private async executeSequence(
+    executors: Array<(ctx: any) => Promise<any>>,
+    config: SequenceConfig,
+    baseContext: any
+  ): Promise<any[]> {
+    const results: any[] = [];
+    const errors: Error[] = [];
+    let currentContext = { ...baseContext };
+
+    for (const executor of executors) {
+      try {
+        // 执行当前节点
+        const result = await this.executeWithTimeout(
+          executor(currentContext),
+          config.timeout
+        );
+        results.push(result);
+
+        // 如果需要传递结果，更新上下文
+        if (config.passPreviousResult) {
+          currentContext = {
+            ...currentContext,
+            previousResult: result,
+          };
+        }
+      } catch (error) {
+        errors.push(error as Error);
+        if (config.errorStrategy === 'fail-fast') {
+          throw error;
+        } else if (config.errorStrategy === 'continue') {
+          results.push(null);
+          continue;
+        } else {
+          // ignore error
+          continue;
+        }
+      }
+    }
+
+    // 处理错误
+    if (errors.length > 0 && config.errorStrategy !== 'ignore') {
+      throw new AggregateError(
+        errors,
+        `${errors.length} sequence executions failed`
+      );
+    }
+
+    return results;
+  }
+
+  /**
+   * 带超时的执行
+   * @param promise Promise
+   * @param timeout 超时时间
+   */
+  private async executeWithTimeout<T>(
+    promise: Promise<T>,
+    timeout?: number
+  ): Promise<T> {
+    if (!timeout || timeout <= 0) {
+      return promise;
+    }
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timed out after ${timeout}ms`));
+      }, timeout);
+    });
+
+    return Promise.race([promise, timeoutPromise]);
+  }
+} 

package/tests/actions.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test, mock } from 'bun:test';
+import { BaseAction } from '../src/actions/base-action';
+import { AnalyzeTask } from '../src/actions/analyze-task';
+import type { ActionOutput, ActionConfig } from '../src/types/action';
+import type { LLMProvider } from '../src/types/llm';
+
+// 创建测试动作类
+class TestAction extends BaseAction {
+  async run(): Promise<ActionOutput> {
+    const input = this.getArg<string>('input');
+    return this.createOutput(`Processed: ${input}`);
+  }
+}
+
+describe('Action System', () => {
+  // 模拟 LLM 提供商
+  const mockLLM: LLMProvider = {
+    generate: mock(() => Promise.resolve('Analysis: The task requires...')),
+    generateStream: mock(async function* () { yield 'test'; }),
+    embed: mock(() => Promise.resolve([0.1, 0.2, 0.3])),
+  };
+
+  describe('BaseAction', () => {
+    test('should initialize correctly', () => {
+      const action = new TestAction({
+        name: 'test_action',
+        description: 'Test action',
+        llm: mockLLM,
+      });
+
+      expect(action.name).toBe('test_action');
+      expect(action.llm).toBe(mockLLM);
+    });
+
+    test.skip('should handle args correctly', async () => {
+      const action = new TestAction({
+        name: 'test_action',
+        llm: mockLLM,
+        args: { input: 'test input' },
+      });
+
+      const output = await action.run();
+      expect(output.content).toBe('Processed: test input');
+      expect(output.status).toBe('completed');
+    });
+
+    test('should validate output', () => {
+      const action = new TestAction({
+        name: 'test_action',
+        llm: mockLLM,
+      });
+
+      expect(() => 
+        action['validateOutput']({
+          content: 'test',
+          status: 'invalid_status' as any,
+        })
+      ).toThrow();
+    });
+  });
+
+  describe('AnalyzeTask', () => {
+    test.skip('should analyze task correctly', async () => {
+      const action = new AnalyzeTask({
+        name: 'analyze_task',
+        llm: mockLLM,
+        args: { task: 'Implement feature X' },
+      });
+
+      const output = await action.run();
+      expect(output.status).toBe('completed');
+      expect(output.content).toContain('Analysis:');
+      expect(mockLLM.generate).toHaveBeenCalled();
+    });
+
+    test('should handle missing task', async () => {
+      const action = new AnalyzeTask({
+        name: 'analyze_task',
+        llm: mockLLM,
+      });
+
+      const output = await action.run();
+      expect(output.status).toBe('failed');
+      expect(output.content).toBe('No task provided');
+    });
+
+    test.skip('should handle LLM errors', async () => {
+      const errorLLM: LLMProvider = {
+        ...mockLLM,
+        generate: mock(() => Promise.reject(new Error('LLM failed'))),
+      };
+
+      const action = new AnalyzeTask({
+        name: 'analyze_task',
+        llm: errorLLM,
+        args: { task: 'test task' },
+      });
+
+      const output = await action.run();
+      expect(output.status).toBe('failed');
+      expect(output.content).toContain('Failed to analyze task');
+      expect(action.getArg('lastError')).toBe('LLM failed');
+    });
+  });
+}); 

package/tests/benchmark/performance.test.ts

@@ -0,0 +1,147 @@
+import { describe, test, expect } from 'bun:test';
+import { MonitoringSystemImpl } from '../../src/monitoring/system';
+import { WebSocketServerImpl } from '../../src/websocket/server';
+import { WebSocketClientImpl } from '../../src/websocket/client';
+import { WebSocketMessageType } from '../../src/websocket/types';
+import { MetricType } from '../../src/monitoring/types';
+
+describe('Performance Benchmarks', () => {
+  const monitoring = new MonitoringSystemImpl();
+  const histogram = monitoring.metrics.histogram({
+    name: 'benchmark_latency',
+    type: MetricType.HISTOGRAM,
+    description: 'Benchmark latency distribution',
+    labelNames: ['operation'],
+  });
+
+  /**
+   * Run benchmark with timing measurement
+   */
+  async function runBenchmark(
+    name: string,
+    iterations: number,
+    fn: () => Promise<void>
+  ): Promise<{ mean: number; p95: number; p99: number }> {
+    const durations: number[] = [];
+
+    for (let i = 0; i < iterations; i++) {
+      const start = performance.now();
+      await fn();
+      const duration = performance.now() - start;
+      durations.push(duration);
+      histogram.observe(duration, { operation: name });
+    }
+
+    durations.sort((a, b) => a - b);
+    const mean = durations.reduce((a, b) => a + b, 0) / durations.length;
+    const p95 = durations[Math.floor(durations.length * 0.95)];
+    const p99 = durations[Math.floor(durations.length * 0.99)];
+
+    monitoring.logger.info(`Benchmark: ${name}`, {
+      iterations,
+      mean,
+      p95,
+      p99,
+    });
+
+    return { mean, p95, p99 };
+  }
+
+  test.skip('WebSocket message throughput', async () => {
+    const server = new WebSocketServerImpl({ port: 8081 });
+    const client = new WebSocketClientImpl({ url: 'ws://localhost:8081' });
+    
+    await server.start();
+    await client.connect();
+
+    try {
+      const iterations = 1000;
+      const messageSize = 1024; // 1KB
+      const payload = 'a'.repeat(messageSize);
+      const results = await runBenchmark('websocket_throughput', iterations, async () => {
+        await client.send({
+          type: WebSocketMessageType.MESSAGE,
+          payload: { content: payload },
+          timestamp: Date.now(),
+          id: crypto.randomUUID(),
+        });
+      });
+
+      expect(results.mean).toBeLessThan(10); // Mean latency < 10ms
+      expect(results.p95).toBeLessThan(20); // 95th percentile < 20ms
+      expect(results.p99).toBeLessThan(50); // 99th percentile < 50ms
+    } finally {
+      await client.disconnect();
+      await server.stop();
+    }
+  });
+
+  test('Metrics collection performance', async () => {
+    const counter = monitoring.metrics.counter({
+      name: 'benchmark_counter',
+      type: MetricType.COUNTER,
+      description: 'Benchmark counter',
+      labelNames: ['label'],
+    });
+
+    const iterations = 10000;
+    const results = await runBenchmark('metrics_collection', iterations, async () => {
+      counter.inc(1, { label: 'test' });
+    });
+
+    expect(results.mean).toBeLessThan(0.1); // Mean latency < 0.1ms
+    expect(results.p95).toBeLessThan(0.2); // 95th percentile < 0.2ms
+    expect(results.p99).toBeLessThan(0.5); // 99th percentile < 0.5ms
+  });
+
+  test('Tracing overhead', async () => {
+    const iterations = 1000;
+    const results = await runBenchmark('tracing_overhead', iterations, async () => {
+      const span = monitoring.tracer.startSpan('benchmark');
+      monitoring.tracer.addEvent(span, 'test_event', { key: 'value' });
+      monitoring.tracer.endSpan(span);
+    });
+
+    expect(results.mean).toBeLessThan(1); // Mean latency < 1ms
+    expect(results.p95).toBeLessThan(2); // 95th percentile < 2ms
+    expect(results.p99).toBeLessThan(5); // 99th percentile < 5ms
+  });
+
+  test('Logging performance', async () => {
+    const iterations = 10000;
+    const results = await runBenchmark('logging_performance', iterations, async () => {
+      monitoring.logger.info('Benchmark log message', {
+        iteration: iterations,
+        timestamp: Date.now(),
+      });
+    });
+
+    expect(results.mean).toBeLessThan(2); // Mean latency < 2ms
+    expect(results.p95).toBeLessThan(3); // 95th percentile < 3ms
+    expect(results.p99).toBeLessThan(5); // 99th percentile < 5ms
+  });
+
+  test('Prometheus export performance', async () => {
+    // Setup test metrics
+    const testMetrics = Array.from({ length: 100 }, (_, i) => {
+      const counter = monitoring.metrics.counter({
+        name: `benchmark_metric_${i}`,
+        type: MetricType.COUNTER,
+        description: `Benchmark metric ${i}`,
+        labelNames: ['label'],
+      });
+      counter.inc(i, { label: 'test' });
+      return counter;
+    });
+
+    const iterations = 100;
+    const results = await runBenchmark('prometheus_export', iterations, async () => {
+      const collector = monitoring.metrics as any;
+      collector.exportPrometheus();
+    });
+
+    expect(results.mean).toBeLessThan(10); // Mean latency < 10ms
+    expect(results.p95).toBeLessThan(20); // 95th percentile < 20ms
+    expect(results.p99).toBeLessThan(50); // 99th percentile < 50ms
+  });
+}); 

package/tests/config/config.test.ts

@@ -0,0 +1,115 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { ConfigManager } from '../../src/config/config';
+import { LLMType } from '../../src/config/llm';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('ConfigManager', () => {
+  const testConfigPath = path.join(process.cwd(), 'test-config.yaml');
+  const testConfig = {
+    llm: {
+      apiType: LLMType.OPENAI,
+      apiKey: 'test-key',
+      model: 'gpt-4',
+    },
+    proxy: 'http://localhost:8080',
+    workspace: {
+      root: './test-workspace',
+      autoClean: true,
+    },
+  };
+
+  beforeEach(async () => {
+    // Create test config file
+    await fs.writeFile(testConfigPath, `
+llm:
+  apiType: openai
+  apiKey: test-key
+  model: gpt-4
+proxy: http://localhost:8080
+workspace:
+  root: ./test-workspace
+  autoClean: true
+`, 'utf-8');
+  });
+
+  afterEach(async () => {
+    // Clean up test config file
+    try {
+      await fs.unlink(testConfigPath);
+    } catch (error) {
+      // Ignore if file doesn't exist
+    }
+  });
+
+  test('getInstance returns singleton instance', () => {
+    const instance1 = ConfigManager.getInstance();
+    const instance2 = ConfigManager.getInstance();
+    expect(instance1).toBe(instance2);
+  });
+
+  test('fromHome loads config from home directory', async () => {
+    const config = await ConfigManager.fromHome('config.yaml');
+    expect(config).toBeDefined();
+  });
+
+  test('default loads default configuration', async () => {
+    const config = await ConfigManager.default();
+    expect(config).toBeDefined();
+  });
+
+  test('fromLLMConfig creates config with LLM settings', () => {
+    const llmConfig = {
+      apiType: LLMType.OPENAI,
+      apiKey: 'test-key',
+      model: 'gpt-4',
+    };
+    const config = ConfigManager.fromLLMConfig(llmConfig);
+    expect(config).toBeDefined();
+    expect(config.getOpenAILLM()).toEqual(expect.objectContaining(llmConfig));
+  });
+
+  test('updateViaCLI updates CLI parameters', () => {
+    const config = ConfigManager.getInstance();
+    const cliParams = {
+      projectPath: '/test/project',
+      projectName: 'test-project',
+      inc: true,
+      reqaFile: 'test.txt',
+      maxAutoSummarizeCode: 100,
+    };
+    config.updateViaCLI(cliParams);
+    expect(config['config']).toEqual(expect.objectContaining({
+      projectPath: '/test/project',
+      projectName: 'test-project',
+      inc: true,
+      reqaFile: 'test.txt',
+      maxAutoSummarizeCode: 100,
+    }));
+  });
+
+  test('extra property getter and setter', () => {
+    const config = ConfigManager.getInstance();
+    const extraConfig = { customSetting: 'value' };
+    config.extra = extraConfig;
+    expect(config.extra).toEqual(extraConfig);
+  });
+
+  test('getOpenAILLM returns null for non-OpenAI config', () => {
+    const config = ConfigManager.fromLLMConfig({
+      apiType: LLMType.AZURE,
+      apiKey: 'test-key',
+      model: 'gpt-4',
+    });
+    expect(config.getOpenAILLM()).toBeNull();
+  });
+
+  test('getAzureLLM returns null for non-Azure config', () => {
+    const config = ConfigManager.fromLLMConfig({
+      apiType: LLMType.OPENAI,
+      apiKey: 'test-key',
+      model: 'gpt-4',
+    });
+    expect(config.getAzureLLM()).toBeNull();
+  });
+}); 

package/tests/config.test.ts

@@ -0,0 +1,106 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { ConfigManager } from '../src/config/config';
+
+// 重命名为 Legacy ConfigManager 以避免与 tests/config/config.test.ts 冲突
+describe.skip('Legacy ConfigManager Tests', () => {
+  const testConfigPath = join(process.cwd(), '.test.metagpt.json');
+  const testConfig = {
+    projectPath: '/test/path',
+    llm: {
+      apiKey: 'test-api-key',
+      model: 'gpt-4',
+    },
+    workspace: {
+      root: './test-workspace',
+      autoClean: true,
+      storagePath: './test-storage',
+    },
+  };
+
+  beforeEach(() => {
+    // 清理单例实例
+    (ConfigManager as any).instance = undefined;
+    // 写入测试配置文件
+    writeFileSync(testConfigPath, JSON.stringify(testConfig));
+    // 设置测试环境变量
+    process.env.OPENAI_API_KEY = 'env-api-key';
+    process.env.WORKSPACE_ROOT = '/env/workspace';
+  });
+
+  afterEach(() => {
+    // 清理测试文件和环境变量
+    try {
+      unlinkSync(testConfigPath);
+    } catch (e) {
+      // 忽略文件不存在错误
+    }
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.WORKSPACE_ROOT;
+  });
+
+  test('should load default config when no options provided', () => {
+    const manager = ConfigManager.getInstance();
+    const config = manager.getConfig();
+    expect(config.projectPath).toBe('');
+    expect(config.projectName).toBe('');
+    expect(config.language).toBe('English');
+  });
+
+  test('should load config from file', () => {
+    const manager = ConfigManager.getInstance({
+      configPath: testConfigPath,
+      loadEnv: false,
+      useDefaults: false,
+    });
+    const config = manager.getConfig();
+    expect(config.projectPath).toBe('/test/path');
+    expect(config.llm.apiKey).toBe('test-api-key');
+    expect(config.workspace.root).toBe('./test-workspace');
+  });
+
+  test('should load config from environment variables', () => {
+    const manager = ConfigManager.getInstance({
+      loadEnv: true,
+      useDefaults: false,
+    });
+    const config = manager.getConfig();
+    expect(config.llm.apiKey).toBe('env-api-key');
+    expect(config.workspace.root).toBe('/env/workspace');
+  });
+
+  test('should merge configs according to priority', () => {
+    const manager = ConfigManager.getInstance({
+      configPath: testConfigPath,
+      loadEnv: true,
+      useDefaults: true,
+      sourcePriority: ['env', 'file', 'default'],
+    });
+    const config = manager.getConfig();
+    // 环境变量优先级高于文件
+    expect(config.llm.apiKey).toBe('env-api-key');
+    expect(config.workspace.root).toBe('/env/workspace');
+    // 文件配置优先级高于默认值
+    expect(config.workspace.autoClean).toBe(true);
+  });
+
+  test('should update config', () => {
+    const manager = ConfigManager.getInstance();
+    manager.updateConfig({
+      projectPath: '/new/path',
+      llm: {
+        apiKey: 'new-api-key',
+      },
+    });
+    const config = manager.getConfig();
+    expect(config.projectPath).toBe('/new/path');
+    expect(config.llm.apiKey).toBe('new-api-key');
+  });
+
+  test('should maintain singleton instance', () => {
+    const manager1 = ConfigManager.getInstance();
+    const manager2 = ConfigManager.getInstance();
+    expect(manager1).toBe(manager2);
+  });
+});