@louloulinx/metagpt 0.1.3

package/tests/plugin/plugin.test.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { PluginManagerImpl } from '../../src/plugin/manager';
+import type { Plugin } from '../../src/plugin/types';
+
+describe('Plugin System', () => {
+  let manager: PluginManagerImpl;
+
+  beforeEach(() => {
+    manager = new PluginManagerImpl();
+  });
+
+  afterEach(async () => {
+    await manager.destroy();
+  });
+
+  describe('Plugin Registration', () => {
+    test('registers valid plugin', async () => {
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        description: 'Test Plugin',
+        hooks: {},
+        init: async () => {},
+        cleanup: async () => {},
+      };
+
+      await manager.register(plugin);
+      expect(manager.getPlugin('test-plugin')).toBe(plugin);
+    });
+
+    test('rejects duplicate plugin registration', async () => {
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        description: 'Test Plugin',
+        hooks: {},
+        init: async () => {},
+        cleanup: async () => {},
+      };
+
+      await manager.register(plugin);
+      await expect(manager.register(plugin)).rejects.toThrow('already registered');
+    });
+
+    test('validates plugin metadata', async () => {
+      const invalidPlugin = {
+        version: '1.0.0',
+        hooks: {},
+        init: async () => {},
+        cleanup: async () => {},
+      };
+
+      await expect(manager.register(invalidPlugin as Plugin)).rejects.toThrow('name is required');
+    });
+  });
+
+  describe('Plugin Dependencies', () => {
+    test('handles plugin dependencies', async () => {
+      const basePlugin: Plugin = {
+        name: 'base-plugin',
+        version: '1.0.0',
+        hooks: {},
+        init: async () => {},
+        cleanup: async () => {},
+      };
+
+      const dependentPlugin: Plugin = {
+        name: 'dependent-plugin',
+        version: '1.0.0',
+        hooks: {},
+        init: async () => {},
+        cleanup: async () => {},
+      };
+
+      await manager.register(basePlugin);
+      await manager.register(dependentPlugin);
+
+      expect(manager.getPlugin('base-plugin')).toBe(basePlugin);
+      expect(manager.getPlugin('dependent-plugin')).toBe(dependentPlugin);
+    });
+
+    test('rejects missing dependencies', async () => {
+      const dependentPlugin: Plugin = {
+        name: 'dependent-plugin',
+        version: '1.0.0',
+        hooks: {},
+        init: async () => {
+          throw new Error('Missing dependency');
+        },
+        cleanup: async () => {},
+      };
+
+      await manager.register(dependentPlugin);
+      await expect(manager.init()).rejects.toThrow('Missing dependency');
+    });
+  });
+
+  describe('Plugin Lifecycle', () => {
+    test('initializes plugins in dependency order', async () => {
+      const initOrder: string[] = [];
+
+      const plugin1: Plugin = {
+        name: 'plugin1',
+        version: '1.0.0',
+        init: async () => {
+          initOrder.push('plugin1');
+        },
+      };
+
+      const plugin2: Plugin = {
+        name: 'plugin2',
+        version: '1.0.0',
+        init: async () => {
+          initOrder.push('plugin2');
+        },
+      };
+
+      await manager.register(plugin1);
+      await manager.register(plugin2);
+      await manager.init();
+
+      expect(initOrder).toEqual(['plugin1', 'plugin2']);
+    });
+
+    test('executes lifecycle hooks', async () => {
+      const hookOrder: string[] = [];
+
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        hooks: {
+          'before-init': async () => {
+            hookOrder.push('before-init');
+          },
+          'init': async () => {
+            hookOrder.push('init');
+          },
+          'after-init': async () => {
+            hookOrder.push('after-init');
+          },
+        },
+      };
+
+      await manager.register(plugin);
+      await manager.init();
+      await manager.executeHook('before-init');
+      await manager.executeHook('init');
+      await manager.executeHook('after-init');
+
+      expect(hookOrder).toEqual(['before-init', 'init', 'after-init']);
+    });
+  });
+
+  describe('Plugin Error Handling', () => {
+    test('handles hook execution errors', async () => {
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        hooks: {
+          'test-hook': async () => {
+            throw new Error('Hook error');
+          },
+        },
+      };
+
+      await manager.register(plugin);
+      await expect(manager.executeHook('test-hook')).rejects.toThrow('Hook error');
+    });
+
+    test('handles plugin initialization errors', async () => {
+      const plugin: Plugin = {
+        name: 'test-plugin',
+        version: '1.0.0',
+        init: async () => {
+          throw new Error('Init error');
+        },
+      };
+
+      await manager.register(plugin);
+      await expect(manager.init()).rejects.toThrow('Init error');
+    });
+  });
+}); 

package/tests/provider/bailian-llm.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it, mock } from 'bun:test';
+import axios from 'axios';
+import { BailianLLMProvider } from '../../src/provider/bailian-llm';
+import type { BailianLLMConfig } from '../../src/provider/bailian-llm';
+
+describe('BailianLLMProvider', () => {
+  const config: BailianLLMConfig = {
+    apiKey: 'test-api-key',
+    secretKey: 'test-secret-key',
+    baseURL: 'https://test-bailian-api.com',
+    model: 'test-model',
+  };
+
+  it('should generate text correctly', async () => {
+    // Mock axios.post
+    const originalPost = axios.post;
+    
+    try {
+      // Replace with mock implementation
+      axios.post = mock(() => 
+        Promise.resolve({
+          data: {
+            output: {
+              text: '这是百炼大模型的回答',
+            },
+          },
+        })
+      );
+
+      const provider = new BailianLLMProvider(config);
+      const result = await provider.generate('测试提示词');
+
+      expect(result).toBe('这是百炼大模型的回答');
+    } finally {
+      // Restore original implementation
+      axios.post = originalPost;
+    }
+  });
+
+  it('should handle errors properly', async () => {
+    // Mock axios.post
+    const originalPost = axios.post;
+    
+    try {
+      // Replace with mock implementation that throws
+      axios.post = mock(() => 
+        Promise.reject({
+          isAxiosError: true,
+          response: {
+            status: 401,
+            data: { error: 'Unauthorized' },
+          },
+          message: 'Request failed with status code 401',
+        })
+      );
+
+      const provider = new BailianLLMProvider(config);
+      
+      try {
+        await provider.generate('测试提示词');
+        // Should not reach here
+        expect(false).toBe(true);
+      } catch (error) {
+        expect((error as Error).message).toContain('Bailian API Error: 401');
+      }
+    } finally {
+      // Restore original implementation
+      axios.post = originalPost;
+    }
+  });
+
+  it('should create embeddings correctly', async () => {
+    // Mock axios.post
+    const originalPost = axios.post;
+    
+    try {
+      // Setup mock response with an embedding vector
+      const mockEmbedding = Array(1536).fill(0).map(() => Math.random());
+      
+      // Replace with mock implementation
+      axios.post = mock(() => 
+        Promise.resolve({
+          data: {
+            embedding: mockEmbedding,
+          },
+        })
+      );
+
+      const provider = new BailianLLMProvider(config);
+      const result = await provider.embed('测试文本');
+
+      expect(result).toEqual(mockEmbedding);
+    } finally {
+      // Restore original implementation
+      axios.post = originalPost;
+    }
+  });
+}); 

package/tests/rag.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, test, mock, beforeAll, afterAll } from 'bun:test';
+import { BaseRAG } from '../src/rag/base-rag';
+import { DocumentQA } from '../src/rag/document-qa';
+import type { RAGConfig, Chunk, SearchResult } from '../src/types/rag';
+import type { LLMProvider } from '../src/types/llm';
+
+// 创建测试 RAG 类
+class TestRAG extends BaseRAG {
+  constructor(config: RAGConfig) {
+    super(config);
+  }
+}
+
+describe.skip('RAG System', () => {
+  // 模拟 LLM 提供商
+  const mockLLM: LLMProvider = {
+    generate: mock(() => Promise.resolve('Generated answer based on context')),
+    generateStream: mock(async function* () { yield 'test'; }),
+    embed: mock(() => Promise.resolve(new Array(384).fill(0.1))),
+  };
+
+  // 测试配置
+  const testConfig: RAGConfig = {
+    llm: mockLLM,
+    vectorStore: {
+      url: 'http://localhost:6333',
+      collectionName: 'test_collection',
+      dimension: 384,
+      distance: 'Cosine',
+    },
+    chunkSize: 1000,
+    chunkOverlap: 200,
+    topK: 5,
+    minScore: 0.7,
+  };
+
+  describe('BaseRAG', () => {
+    let rag: TestRAG;
+
+    beforeAll(async () => {
+      rag = new TestRAG(testConfig);
+      // 创建测试集合
+      await rag['vectorStore'].createCollection(testConfig.vectorStore.collectionName, {
+        vectors: {
+          size: testConfig.vectorStore.dimension,
+          distance: testConfig.vectorStore.distance.toLowerCase(),
+        },
+      });
+    });
+
+    afterAll(async () => {
+      // 清理测试集合
+      await rag['vectorStore'].deleteCollection(testConfig.vectorStore.collectionName);
+    });
+
+    test.skip('should initialize correctly', () => {
+      expect(rag.llm).toBe(mockLLM);
+      expect(rag.config).toEqual(testConfig);
+    });
+
+    test.skip('should add and retrieve documents', async () => {
+      const testDoc = 'This is a test document for RAG system testing.';
+      const chunks = await rag.addDocument(testDoc, { source: 'test' });
+
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks[0].content).toBe(testDoc);
+      expect(chunks[0].metadata).toEqual({ source: 'test' });
+
+      const results = await rag.search('test document');
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].chunk.content).toBe(testDoc);
+    });
+
+    test.skip('should generate answers', async () => {
+      const answer = await rag.generate('What is this document about?');
+      expect(answer).toBe('Generated answer based on context');
+      expect(mockLLM.generate).toHaveBeenCalled();
+    });
+
+    test.skip('should delete chunks', async () => {
+      const chunks = await rag.addDocument('Document to be deleted');
+      await rag.deleteChunks([chunks[0].id]);
+
+      const results = await rag.search('deleted document');
+      expect(results.length).toBe(0);
+    });
+
+    test.skip('should update chunks', async () => {
+      const chunks = await rag.addDocument('Original content');
+      const updatedChunk: Chunk = {
+        ...chunks[0],
+        content: 'Updated content',
+      };
+
+      await rag.updateChunk(updatedChunk);
+      const results = await rag.search('Updated content');
+      expect(results[0].chunk.content).toBe('Updated content');
+    });
+  });
+
+  describe('DocumentQA', () => {
+    let qa: DocumentQA;
+
+    beforeAll(async () => {
+      qa = new DocumentQA(testConfig);
+      await qa['vectorStore'].createCollection(testConfig.vectorStore.collectionName, {
+        vectors: {
+          size: testConfig.vectorStore.dimension,
+          distance: testConfig.vectorStore.distance.toLowerCase(),
+        },
+      });
+    });
+
+    afterAll(async () => {
+      await qa['vectorStore'].deleteCollection(testConfig.vectorStore.collectionName);
+    });
+
+    test.skip('should handle document chunks intelligently', async () => {
+      const testDoc = `
+Paragraph 1: This is the first paragraph.
+
+Paragraph 2: This is the second paragraph.
+
+Paragraph 3: This is the third paragraph.
+      `.trim();
+
+      const chunks = await qa['chunkText'](testDoc);
+      expect(chunks.length).toBe(1); // Small enough to be one chunk
+      expect(chunks[0]).toContain('Paragraph 1');
+      expect(chunks[0]).toContain('Paragraph 2');
+      expect(chunks[0]).toContain('Paragraph 3');
+    });
+
+    test.skip('should generate answers with citations', async () => {
+      await qa.addDocument('Important information about the topic.');
+
+      const { answer, citations } = await qa.generateWithCitations('What is the topic?');
+      expect(answer).toBe('Generated answer based on context');
+      expect(citations.length).toBeGreaterThan(0);
+      expect(citations[0].content).toContain('Important information');
+    });
+
+    test.skip('should build appropriate prompts', () => {
+      const query = 'Test question';
+      const results: SearchResult[] = [{
+        chunk: {
+          id: '1',
+          content: 'Test content',
+          embedding: [],
+          metadata: {},
+        },
+        score: 0.9,
+        metadata: {},
+      }];
+
+      const prompt = qa['buildPrompt'](query, results);
+      expect(prompt).toContain('Reference passages');
+      expect(prompt).toContain('Test question');
+      expect(prompt).toContain('[1] Test content');
+    });
+  });
+}); 

package/tests/roles.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test, mock } from 'bun:test';
+import { Engineer } from '../src/roles/engineer';
+import type { Message } from '../src/types/message';
+import type { Action, ActionOutput } from '../src/types/action';
+import type { LLMProvider } from '../src/types/llm';
+
+describe('Role 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])),
+  };
+
+  // 模拟动作
+  const mockAction: Action = {
+    name: 'test_action',
+    context: {} as any,
+    llm: mockLLM,
+    run: mock(() => Promise.resolve({
+      content: 'Action completed',
+      status: 'completed',
+    } as ActionOutput)),
+    handleException: mock(() => Promise.resolve()),
+  };
+
+  describe('Engineer Role', () => {
+    test('should initialize correctly', () => {
+      const engineer = new Engineer('test_engineer', mockLLM, [mockAction]);
+      expect(engineer.name).toBe('test_engineer');
+      expect(engineer.profile).toBe('Software Engineer');
+      expect(engineer.state).toBe(-1);
+    });
+
+    test('should observe and analyze tasks', async () => {
+      const engineer = new Engineer('test_engineer', mockLLM, [mockAction]);
+      
+      // 模拟一条消息
+      const message: Message = {
+        id: 'test_message',
+        content: 'Implement feature X',
+        role: 'user',
+        causedBy: 'user_request',
+        sentFrom: 'user',
+        sendTo: new Set(['test_engineer']),
+      };
+
+      // 添加消息到内存
+      engineer.context.memory.add(message);
+
+      // 执行观察
+      const state = await engineer.observe();
+      expect(state).toBeGreaterThanOrEqual(-1);
+      expect(mockLLM.generate).toHaveBeenCalled();
+    });
+
+    test('should think and select action', async () => {
+      const engineer = new Engineer('test_engineer', mockLLM, [mockAction]);
+      
+      // 执行思考
+      const hasAction = await engineer.think();
+      expect(hasAction).toBe(true);
+      expect(engineer.context.todo).toBe(mockAction);
+    });
+
+    test('should execute actions', async () => {
+      const engineer = new Engineer('test_engineer', mockLLM, [mockAction]);
+      
+      // 设置动作并执行
+      await engineer.think();
+      const result = await engineer.act();
+      
+      expect(result.content).toBe('Action completed');
+      expect(mockAction.run).toHaveBeenCalled();
+    });
+
+    test('should handle action errors', async () => {
+      const engineer = new Engineer('test_engineer', mockLLM, [mockAction]);
+      
+      // 模拟动作执行失败
+      mockAction.run = mock(() => Promise.reject(new Error('Action failed')));
+      
+      await engineer.think();
+      await expect(engineer.act()).rejects.toThrow('Action failed');
+      expect(mockAction.handleException).toHaveBeenCalled();
+    });
+  });
+}); 

package/tests/skills.test.ts

@@ -0,0 +1,166 @@
+import { describe, expect, test, mock } from 'bun:test';
+import { BaseSkill } from '../src/skills/base-skill';
+import { CodeReviewSkill } from '../src/skills/code-review';
+import type { SkillConfig, SkillResult } from '../src/types/skill';
+import type { Action, ActionOutput } from '../src/types/action';
+import type { LLMProvider } from '../src/types/llm';
+
+// 创建测试技能类
+class TestSkill extends BaseSkill {
+  async execute(args?: Record<string, any>): Promise<SkillResult> {
+    const input = args?.input || 'default';
+    return this.createResult(true, `Processed: ${input}`);
+  }
+}
+
+// 创建测试动作类
+class TestAction implements Action {
+  name: string;
+  context: any;
+  llm: LLMProvider;
+
+  constructor(name: string, llm: LLMProvider) {
+    this.name = name;
+    this.llm = llm;
+    this.context = { args: {} };
+  }
+
+  async run(): Promise<ActionOutput> {
+    return {
+      content: 'Test action completed',
+      status: 'completed',
+    };
+  }
+
+  async handleException(error: Error): Promise<void> {
+    console.error(error);
+  }
+}
+
+describe('Skill System', () => {
+  // 模拟 LLM 提供商
+  const mockLLM: LLMProvider = {
+    generate: mock(() => Promise.resolve('Analysis: The code needs improvement...')),
+    generateStream: mock(async function* () { yield 'test'; }),
+    embed: mock(() => Promise.resolve([0.1, 0.2, 0.3])),
+  };
+
+  describe('BaseSkill', () => {
+    test('should initialize correctly', () => {
+      const skill = new TestSkill({
+        name: 'test_skill',
+        description: 'Test skill',
+        llm: mockLLM,
+      });
+
+      expect(skill.name).toBe('test_skill');
+      expect(skill.description).toBe('Test skill');
+      expect(skill.llm).toBe(mockLLM);
+    });
+
+    test('should handle args correctly', async () => {
+      const skill = new TestSkill({
+        name: 'test_skill',
+        description: 'Test skill',
+        llm: mockLLM,
+        args: { input: 'test input' },
+      });
+
+      const result = await skill.execute({ input: 'test input' });
+      expect(result.success).toBe(true);
+      expect(result.message).toBe('Processed: test input');
+    });
+
+    test('should validate skill availability', async () => {
+      const skill = new TestSkill({
+        name: 'test_skill',
+        description: 'Test skill',
+        llm: mockLLM,
+      });
+
+      const isValid = await skill.validate();
+      expect(isValid).toBe(false); // No actions added
+
+      skill.actions.push(new TestAction('test_action', mockLLM));
+      const isValidWithAction = await skill.validate();
+      expect(isValidWithAction).toBe(true);
+    });
+  });
+
+  describe('CodeReviewSkill', () => {
+    test('should review code correctly', async () => {
+      const skill = new CodeReviewSkill({
+        name: 'code_review',
+        description: 'Code review skill',
+        llm: mockLLM,
+      });
+
+      const result = await skill.execute({
+        code: `
+function add(a, b) {
+  return a + b;
+}`,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.message).toBe('Code review completed successfully');
+      expect(mockLLM.generate).toHaveBeenCalled();
+    });
+
+    test('should handle missing code', async () => {
+      const skill = new CodeReviewSkill({
+        name: 'code_review',
+        description: 'Code review skill',
+        llm: mockLLM,
+      });
+
+      const result = await skill.execute();
+      expect(result.success).toBe(false);
+      expect(result.message).toBe('No code provided for review');
+    });
+
+    test('should extract suggestions', async () => {
+      const skill = new CodeReviewSkill({
+        name: 'code_review',
+        description: 'Code review skill',
+        llm: mockLLM,
+      });
+
+      mockLLM.generate = mock(() => Promise.resolve(`
+Analysis:
+Some analysis text...
+
+Suggested Improvements:
+1. Add type annotations
+2. Include error handling
+3. Improve documentation
+`));
+
+      const result = await skill.execute({ code: 'test code' });
+      expect(result.success).toBe(true);
+      expect((result.data as any).suggestions).toEqual([
+        'Add type annotations',
+        'Include error handling',
+        'Improve documentation',
+      ]);
+    });
+
+    test.skip('should handle LLM errors', async () => {
+      const errorLLM: LLMProvider = {
+        ...mockLLM,
+        generate: mock(() => Promise.reject(new Error('LLM failed'))),
+      };
+
+      const skill = new CodeReviewSkill({
+        name: 'code_review',
+        description: 'Code review skill',
+        llm: errorLLM,
+      });
+
+      const result = await skill.execute({ code: 'test code' });
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Code review failed');
+      expect(skill.getArg('lastError')).toBe('LLM failed');
+    });
+  });
+});