@louloulinx/metagpt 0.1.3

package/tests/team.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test, mock, beforeAll, afterAll } from 'bun:test';
+import { Team } from '../src/management/team';
+import { Context } from '../src/context/context';
+import { Environment } from '../src/environment/environment';
+import { Role } from '../src/types/role';
+import { Message } from '../src/types/message';
+import { NoMoneyError } from '../src/utils/errors';
+
+describe('Team Management', () => {
+  // Mock role class for testing
+  class TestRole implements Role {
+    name = 'TestRole';
+    profile = 'Test profile';
+    goal = 'Test goal';
+    constraints = 'Test constraints';
+    
+    async observe(): Promise<number> {
+      return 0;
+    }
+    
+    async think(): Promise<boolean> {
+      return true;
+    }
+    
+    async act(): Promise<Message> {
+      return new Message({
+        role: this.name,
+        content: 'Test action',
+        causedBy: 'TestAction'
+      });
+    }
+  }
+
+  describe('Team Initialization', () => {
+    test('should create team with default config', () => {
+      const team = new Team({});
+      expect(team).toBeDefined();
+      expect(team.costManager).toBeDefined();
+    });
+
+    test('should create team with custom config', () => {
+      const context = new Context();
+      const env = new Environment({ context });
+      const roles = [new TestRole()];
+
+      const team = new Team({
+        environment: env,
+        investment: 100,
+        idea: 'Test idea',
+        context,
+        roles,
+        envDesc: 'Test environment'
+      });
+
+      expect(team).toBeDefined();
+      expect(team.costManager.maxBudget).toBe(100);
+    });
+  });
+
+  describe('Team Operations', () => {
+    let team: Team;
+    let role: TestRole;
+
+    beforeAll(() => {
+      team = new Team({});
+      role = new TestRole();
+    });
+
+    test('should hire roles', () => {
+      team.hire([role]);
+      // Verify through running a project
+      team.runProject('Test project');
+      expect(team['env'].roles).toContain(role);
+    });
+
+    test('should invest funds', () => {
+      team.invest(200);
+      expect(team.costManager.maxBudget).toBe(200);
+    });
+
+    test('should throw error on insufficient funds', () => {
+      team.costManager.totalCost = 300;
+      expect(() => team['checkBalance']()).toThrow(NoMoneyError);
+    });
+  });
+
+  describe('Project Execution', () => {
+    let team: Team;
+    let role: TestRole;
+
+    beforeAll(() => {
+      team = new Team({});
+      role = new TestRole();
+      team.hire([role]);
+      team.invest(1000);
+    });
+
+    test('should run project with idea', async () => {
+      const history = await team.run(1, 'Test project');
+      expect(history.length).toBeGreaterThan(0);
+      expect(history[0].content).toBe('Test project');
+    });
+
+    test('should stop when roles are idle', async () => {
+      team['env'].isIdle = true;
+      const history = await team.run(5, 'Test idle');
+      expect(history.length).toBeGreaterThan(0);
+    });
+
+    test('should archive after completion', async () => {
+      const mockArchive = mock(() => Promise.resolve());
+      team['env'].archive = mockArchive;
+      
+      await team.run(1, 'Test archive');
+      expect(mockArchive).toHaveBeenCalled();
+    });
+  });
+
+  describe('Serialization', () => {
+    let team: Team;
+    const storagePath = './test-storage';
+
+    beforeAll(() => {
+      team = new Team({
+        investment: 500,
+        idea: 'Test serialization'
+      });
+    });
+
+    test('should serialize team state', () => {
+      team.serialize(storagePath);
+      // Verify file exists and content
+      const deserializedTeam = Team.deserialize(storagePath);
+      expect(deserializedTeam['config'].investment).toBe(500);
+      expect(deserializedTeam['config'].idea).toBe('Test serialization');
+    });
+
+    afterAll(() => {
+      // Clean up test storage
+      // TODO: Implement cleanup
+    });
+  });
+}); 

package/tests/tools.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test, mock, beforeEach, afterEach } from 'bun:test';
+import { BaseTool } from '../src/tools/base-tool';
+import { FileSystemTool } from '../src/tools/file-system';
+import type { ToolConfig, ToolResult } from '../src/types/tool';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
+// 创建测试工具类
+class TestTool extends BaseTool {
+  constructor(config?: Partial<ToolConfig>) {
+    super({
+      name: 'test_tool',
+      description: 'Test tool',
+      version: '1.0.0',
+      category: 'test',
+      ...config,
+    });
+  }
+
+  async execute(args?: Record<string, any>): Promise<ToolResult> {
+    const input = args?.input || 'default';
+    return this.createResult(true, `Processed: ${input}`);
+  }
+}
+
+describe('Tool System', () => {
+  describe('BaseTool', () => {
+    test('should initialize correctly', () => {
+      const tool = new TestTool({
+        name: 'custom_tool',
+        description: 'Custom tool',
+        version: '2.0.0',
+        category: 'custom',
+      });
+
+      expect(tool.name).toBe('custom_tool');
+      expect(tool.description).toBe('Custom tool');
+      expect(tool.version).toBe('2.0.0');
+      expect(tool.category).toBe('custom');
+    });
+
+    test('should handle args correctly', async () => {
+      const tool = new TestTool();
+      const result = await tool.execute({ input: 'test input' });
+      expect(result.success).toBe(true);
+      expect(result.message).toBe('Processed: test input');
+    });
+
+    test('should validate tool availability', async () => {
+      const tool = new TestTool();
+      const isValid = await tool.validate();
+      expect(isValid).toBe(true);
+    });
+
+    test('should provide help information', () => {
+      const tool = new TestTool();
+      const help = tool.getHelp();
+      expect(help).toContain('Test tool');
+      expect(help).toContain('1.0.0');
+      expect(help).toContain('test');
+    });
+  });
+
+  describe('FileSystemTool', () => {
+    const testDir = './test-files';
+    const testFile = join(testDir, 'test.txt');
+    const testContent = 'Hello, World!';
+
+    beforeEach(async () => {
+      await fs.mkdir(testDir, { recursive: true });
+    });
+
+    afterEach(async () => {
+      try {
+        await fs.rm(testDir, { recursive: true, force: true });
+      } catch (error) {
+        console.error('Failed to cleanup:', error);
+      }
+    });
+
+    test('should write and read file', async () => {
+      const tool = new FileSystemTool();
+
+      // Write file
+      const writeResult = await tool.execute({
+        operation: 'write',
+        path: testFile,
+        content: testContent,
+      });
+      expect(writeResult.success).toBe(true);
+
+      // Read file
+      const readResult = await tool.execute({
+        operation: 'read',
+        path: testFile,
+      });
+      expect(readResult.success).toBe(true);
+      expect(readResult.data?.content).toBe(testContent);
+    });
+
+    test('should list directory', async () => {
+      const tool = new FileSystemTool();
+
+      // Create test files
+      await fs.writeFile(join(testDir, 'file1.txt'), 'content1');
+      await fs.writeFile(join(testDir, 'file2.txt'), 'content2');
+      await fs.mkdir(join(testDir, 'subdir'), { recursive: true });
+
+      const result = await tool.execute({
+        operation: 'list',
+        path: testDir,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data?.files).toHaveLength(3);
+      expect(result.data?.files.some((f: any) => f.name === 'file1.txt')).toBe(true);
+      expect(result.data?.files.some((f: any) => f.name === 'subdir' && f.isDirectory)).toBe(true);
+    });
+
+    test('should delete file', async () => {
+      const tool = new FileSystemTool();
+
+      // Create and then delete file
+      await fs.writeFile(testFile, testContent);
+      const result = await tool.execute({
+        operation: 'delete',
+        path: testFile,
+      });
+
+      expect(result.success).toBe(true);
+      await expect(fs.access(testFile)).rejects.toThrow();
+    });
+
+    test('should handle missing file', async () => {
+      const tool = new FileSystemTool();
+
+      const result = await tool.execute({
+        operation: 'read',
+        path: join(testDir, 'non-existent.txt'),
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Failed to read file');
+    });
+
+    test('should handle invalid operations', async () => {
+      const tool = new FileSystemTool();
+
+      const result = await tool.execute({
+        operation: 'invalid',
+        path: testFile,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Unknown operation');
+    });
+
+    test.skip('should track errors', async () => {
+      const tool = new FileSystemTool();
+
+      await tool.execute({
+        operation: 'read',
+        path: join(testDir, 'non-existent.txt'),
+      });
+
+      expect(tool.getState('lastError')).toBeDefined();
+      expect(tool.getState('errorTimestamp')).toBeDefined();
+    });
+  });
+}); 

package/tests/types/document.test.ts

@@ -0,0 +1,181 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import path from 'path';
+import fs from 'fs/promises';
+import {
+  DocumentStatus,
+  DocumentImpl,
+  IndexableDocumentImpl,
+  RepoImpl,
+} from '../../src/types/document';
+
+describe('Document System', () => {
+  const testDir = path.join(process.cwd(), 'test-docs');
+  const testFile = path.join(testDir, 'test.txt');
+  const testContent = 'Test content';
+
+  beforeEach(async () => {
+    await fs.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore errors
+    }
+  });
+
+  describe('DocumentImpl', () => {
+    test('creates document with default values', () => {
+      const doc = new DocumentImpl();
+      expect(doc.name).toBe('');
+      expect(doc.content).toBe('');
+      expect(doc.author).toBe('');
+      expect(doc.status).toBe(DocumentStatus.DRAFT);
+      expect(doc.reviews).toEqual([]);
+    });
+
+    test('creates document from text', () => {
+      const doc = DocumentImpl.fromText(testContent, testFile);
+      expect(doc.content).toBe(testContent);
+      expect(doc.path).toBe(testFile);
+      expect(doc.name).toBe(path.basename(testFile));
+    });
+
+    test('creates document from path', async () => {
+      await fs.writeFile(testFile, testContent);
+      const doc = await DocumentImpl.fromPath(testFile);
+      expect(doc.content).toBe(testContent);
+      expect(doc.path).toBe(testFile);
+      expect(doc.name).toBe(path.basename(testFile));
+    });
+
+    test('saves document to path', async () => {
+      const doc = new DocumentImpl({
+        content: testContent,
+        path: testFile,
+      });
+      await doc.toPath();
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe(testContent);
+    });
+
+    test('throws error when saving without path', async () => {
+      const doc = new DocumentImpl({ content: testContent });
+      await expect(doc.toPath()).rejects.toThrow('File path is not set');
+    });
+  });
+
+  describe('IndexableDocumentImpl', () => {
+    const jsonFile = path.join(testDir, 'test.json');
+    const csvFile = path.join(testDir, 'test.csv');
+
+    test('creates indexable document from JSON', async () => {
+      const jsonData = { key: 'value', content: 'test content' };
+      await fs.writeFile(jsonFile, JSON.stringify(jsonData));
+      const doc = await IndexableDocumentImpl.fromPath(jsonFile);
+      expect(doc.data).toEqual(jsonData);
+    });
+
+    test('creates indexable document from CSV', async () => {
+      const csvContent = 'header1,header2\nvalue1,value2';
+      await fs.writeFile(csvFile, csvContent);
+      const doc = await IndexableDocumentImpl.fromPath(csvFile);
+      const data = doc.data as string[][];
+      expect(Array.isArray(data)).toBe(true);
+      expect(data[0]).toEqual(['header1', 'header2']);
+      expect(data[1]).toEqual(['value1', 'value2']);
+    });
+
+    test('extracts docs and metadata from array data', () => {
+      const data = [
+        { content: 'doc1', metadata: 'meta1' },
+        { content: 'doc2', metadata: 'meta2' },
+      ];
+      const doc = new IndexableDocumentImpl({
+        data,
+        contentCol: 'content',
+        metaCol: 'metadata',
+      });
+      const [docs, metadata] = doc.getDocsAndMetadata();
+      expect(docs).toEqual(['doc1', 'doc2']);
+      expect(metadata).toEqual([
+        { metadata: 'meta1' },
+        { metadata: 'meta2' },
+      ]);
+    });
+
+    test('extracts docs and metadata from record data', () => {
+      const data = {
+        key1: { content: 'doc1', metadata: 'meta1' },
+        key2: { content: 'doc2', metadata: 'meta2' },
+      };
+      const doc = new IndexableDocumentImpl({
+        data,
+        contentCol: 'content',
+        metaCol: 'metadata',
+      });
+      const [docs, metadata] = doc.getDocsAndMetadata();
+      expect(docs).toEqual(['doc1', 'doc2']);
+      expect(metadata).toEqual([
+        { metadata: 'meta1' },
+        { metadata: 'meta2' },
+      ]);
+    });
+  });
+
+  describe('RepoImpl', () => {
+    test('creates repository with default values', () => {
+      const repo = new RepoImpl();
+      expect(repo.name).toBe('');
+      expect(repo.docs).toEqual({});
+      expect(repo.codes).toEqual({});
+      expect(repo.assets).toEqual({});
+    });
+
+    test('creates repository from path', async () => {
+      // Create test files
+      const mdFile = path.join(testDir, 'test.md');
+      const jsFile = path.join(testDir, 'test.js');
+      const txtFile = path.join(testDir, 'test.txt');
+
+      await fs.writeFile(mdFile, '# Test markdown');
+      await fs.writeFile(jsFile, 'console.log("test");');
+      await fs.writeFile(txtFile, 'Test text');
+
+      const repo = await RepoImpl.fromPath(testDir);
+      expect(repo.name).toBe(path.basename(testDir));
+      expect(Object.keys(repo.docs)).toHaveLength(1); // .md file
+      expect(Object.keys(repo.codes)).toHaveLength(1); // .js file
+      expect(Object.keys(repo.assets)).toHaveLength(1); // .txt file
+    });
+
+    test('sets and gets documents', async () => {
+      const repo = new RepoImpl({ path: testDir });
+      await repo.set('test.md', '# Test');
+      const doc = repo.get('test.md');
+      expect(doc?.content).toBe('# Test');
+    });
+
+    test('gets text documents', async () => {
+      const repo = new RepoImpl({ path: testDir });
+      await repo.set('test.md', '# Test markdown');
+      await repo.set('test.js', 'console.log("test");');
+      await repo.set('test.txt', 'Test text');
+
+      const textDocs = repo.getTextDocuments();
+      expect(textDocs).toHaveLength(2); // .md and .js files
+    });
+
+    test('gets repository metadata', async () => {
+      const repo = new RepoImpl({ path: testDir, name: 'test-repo' });
+      await repo.set('test.md', '# Test');
+      await repo.set('test.js', 'test');
+
+      const metadata = repo.getMetadata();
+      expect(metadata.name).toBe('test-repo');
+      expect(metadata.nDocs).toBe(2);
+      expect(metadata.nChars).toBe(10); // '# Test' (6 chars) + 'test' (4 chars)
+    });
+  });
+}); 

package/tests/types/message.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect } from 'bun:test';
+import type { Message } from '../../src/types/message';
+import {
+  MessageSchema,
+  UserMessage,
+  SystemMessage,
+  AIMessage,
+  AsyncMessageQueue,
+  MESSAGE_ROUTE,
+} from '../../src/types/message';
+
+describe('Message System', () => {
+  describe('MessageSchema', () => {
+    test('validates and transforms valid message data', () => {
+      const data = {
+        content: 'test message',
+        role: 'user',
+        sendTo: ['user1', 'user2'],
+      };
+      const message = MessageSchema.parse(data);
+      expect(message.content).toBe('test message');
+      expect(message.role).toBe('user');
+      expect(message.id).toBeDefined();
+      expect(message.sendTo instanceof Set).toBe(true);
+      expect(Array.from(message.sendTo)).toEqual(['user1', 'user2']);
+    });
+
+    test('provides default values for optional fields', () => {
+      const data = {
+        content: 'test message',
+      };
+      const message = MessageSchema.parse(data);
+      expect(message.role).toBe('user');
+      expect(message.causedBy).toBe(MESSAGE_ROUTE.CAUSE_BY);
+      expect(message.sentFrom).toBe(MESSAGE_ROUTE.FROM);
+      expect(message.sendTo instanceof Set).toBe(true);
+      expect(Array.from(message.sendTo)).toEqual([MESSAGE_ROUTE.TO_ALL]);
+    });
+  });
+
+  describe('Message Classes', () => {
+    test('UserMessage creates message with user role', () => {
+      const msg = new UserMessage('test content');
+      expect(msg.role).toBe('user');
+      expect(msg.content).toBe('test content');
+      expect(msg.id).toBeDefined();
+    });
+
+    test('SystemMessage creates message with system role', () => {
+      const msg = new SystemMessage('test content');
+      expect(msg.role).toBe('system');
+      expect(msg.content).toBe('test content');
+      expect(msg.id).toBeDefined();
+    });
+
+    test('AIMessage creates message with assistant role', () => {
+      const msg = new AIMessage('test content');
+      expect(msg.role).toBe('assistant');
+      expect(msg.content).toBe('test content');
+      expect(msg.id).toBeDefined();
+    });
+  });
+
+  describe('AsyncMessageQueue', () => {
+    test('push and pop messages', async () => {
+      const queue = new AsyncMessageQueue();
+      const msg = new UserMessage('test message');
+      queue.push(msg);
+      expect(queue.empty()).toBe(false);
+      
+      const popped = await queue.pop();
+      expect(popped).toEqual(msg);
+      expect(queue.empty()).toBe(true);
+    });
+
+    test('pop returns null for empty queue', async () => {
+      const queue = new AsyncMessageQueue();
+      const msg = await queue.pop();
+      expect(msg).toBeNull();
+    });
+
+    test('popAll returns all messages', async () => {
+      const queue = new AsyncMessageQueue();
+      const msgs = [
+        new UserMessage('msg1'),
+        new SystemMessage('msg2'),
+        new AIMessage('msg3'),
+      ];
+      msgs.forEach(msg => queue.push(msg));
+      
+      const popped = await queue.popAll();
+      expect(popped).toEqual(msgs);
+      expect(queue.empty()).toBe(true);
+    });
+
+    test('dump and load queue state', async () => {
+      const queue = new AsyncMessageQueue();
+      const msgs = [
+        new UserMessage('msg1'),
+        new SystemMessage('msg2'),
+        new AIMessage('msg3'),
+      ];
+      msgs.forEach(msg => queue.push(msg));
+      
+      const dumped = await queue.dump();
+      const loaded = AsyncMessageQueue.load(dumped);
+      
+      expect(loaded.empty()).toBe(false);
+      const loadedMsgs = await loaded.popAll();
+      expect(loadedMsgs.length).toBe(msgs.length);
+      loadedMsgs.forEach((msg, i) => {
+        expect(msg.content).toBe(msgs[i].content);
+        expect(msg.role).toBe(msgs[i].role);
+      });
+    });
+
+    test('handles invalid JSON when loading', () => {
+      const queue = AsyncMessageQueue.load('invalid json');
+      expect(queue.empty()).toBe(true);
+    });
+  });
+});