@louloulinx/metagpt 0.1.3

package/src/management/team.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { Environment } from '../environment/environment';
+import { Context } from '../context/context';
+import { Message } from '../types/message';
+import { Role } from '../types/role';
+import { TeamConfig, TeamConfigSchema, TeamState, TeamStateSchema } from '../types/team';
+import { NoMoneyError } from '../utils/errors';
+import { readJsonFile, writeJsonFile } from '../utils/file';
+import { join } from 'path';
+
+/**
+ * Team class for managing multiple roles (agents) and their interactions
+ */
+export class Team {
+  private config: TeamConfig;
+  private state: TeamState;
+  private env: Environment;
+
+  /**
+   * Create a new team instance
+   * @param config Team configuration
+   */
+  constructor(config: TeamConfig) {
+    this.config = TeamConfigSchema.parse(config);
+    this.state = TeamStateSchema.parse({});
+    
+    const context = config.context || new Context();
+    this.env = config.environment || new Environment({ context });
+    
+    if (config.roles) {
+      this.hire(config.roles);
+    }
+    
+    if (config.envDesc) {
+      this.env.setDescription(config.envDesc);
+    }
+  }
+
+  /**
+   * Hire roles to join the team
+   * @param roles List of roles to hire
+   */
+  public hire(roles: Role[]): void {
+    this.env.addRoles(roles);
+  }
+
+  /**
+   * Get the cost manager
+   */
+  public get costManager() {
+    return this.env.context.costManager;
+  }
+
+  /**
+   * Invest in the team
+   * @param amount Investment amount
+   */
+  public invest(amount: number): void {
+    this.config.investment = amount;
+    this.costManager.maxBudget = amount;
+    console.log(`Investment: $${amount}`);
+  }
+
+  /**
+   * Check if team has sufficient balance
+   * @throws {NoMoneyError} If insufficient funds
+   */
+  private checkBalance(): void {
+    if (this.costManager.totalCost >= this.costManager.maxBudget) {
+      throw new NoMoneyError(
+        this.costManager.totalCost,
+        `Insufficient funds: ${this.costManager.maxBudget}`
+      );
+    }
+  }
+
+  /**
+   * Run a project with given idea
+   * @param idea Project idea or requirement
+   * @param sendTo Target role (optional)
+   */
+  public runProject(idea: string, sendTo = ''): void {
+    this.config.idea = idea;
+
+    // Publish human requirement
+    this.env.publishMessage(
+      new Message({
+        role: 'Human',
+        content: idea,
+        causedBy: 'UserRequirement',
+        sendTo: sendTo || 'ALL'
+      })
+    );
+  }
+
+  /**
+   * Run the team for specified rounds
+   * @param rounds Number of rounds to run
+   * @param idea Optional project idea
+   * @param sendTo Optional target role
+   * @param autoArchive Whether to auto archive after completion
+   */
+  public async run(
+    rounds = 3,
+    idea = '',
+    sendTo = '',
+    autoArchive = true
+  ): Promise<Message[]> {
+    if (idea) {
+      this.runProject(idea, sendTo);
+    }
+
+    while (rounds > 0) {
+      if (this.env.isIdle) {
+        console.debug('All roles are idle.');
+        break;
+      }
+
+      rounds--;
+      this.checkBalance();
+      await this.env.run();
+
+      console.debug(`Max ${rounds} rounds left.`);
+    }
+
+    if (autoArchive) {
+      await this.env.archive();
+    }
+
+    return this.env.history;
+  }
+
+  /**
+   * Serialize team state to storage
+   * @param storagePath Storage path
+   */
+  public serialize(storagePath: string): void {
+    const teamPath = join(storagePath, 'team');
+    const teamInfoPath = join(teamPath, 'team.json');
+
+    const data = {
+      config: this.config,
+      state: this.state,
+      context: this.env.context.serialize()
+    };
+
+    writeJsonFile(teamInfoPath, data);
+  }
+
+  /**
+   * Deserialize team state from storage
+   * @param storagePath Storage path
+   * @param context Optional context
+   */
+  public static deserialize(storagePath: string, context?: Context): Team {
+    const teamPath = join(storagePath, 'team');
+    const teamInfoPath = join(teamPath, 'team.json');
+
+    const data = readJsonFile(teamInfoPath);
+    const ctx = context || new Context();
+    ctx.deserialize(data.context);
+
+    return new Team({
+      ...data.config,
+      context: ctx
+    });
+  }
+} 

package/src/memory/longterm.ts

@@ -0,0 +1,218 @@
+import type { LongTermMemory, WorkingMemory } from './types';
+import type { MemoryEntrySchema, MemoryQueryOptions } from './types';
+import type { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Long-term memory implementation with persistence and consolidation
+ */
+export class LongTermMemoryImpl implements LongTermMemory {
+  private memories: Map<string, z.infer<typeof MemoryEntrySchema>> = new Map();
+
+  /**
+   * Add a new memory
+   */
+  public async add(
+    content: string,
+    type: string,
+    metadata: Record<string, any> = {}
+  ): Promise<z.infer<typeof MemoryEntrySchema>> {
+    const memory = {
+      id: uuidv4(),
+      content,
+      type,
+      timestamp: Date.now(),
+      metadata,
+      importance: metadata.importance ?? 0.5,
+      embedding: metadata.embedding ?? [],
+    };
+
+    this.memories.set(memory.id, memory);
+    return memory;
+  }
+
+  /**
+   * Get a memory by ID
+   */
+  public async get(id: string): Promise<z.infer<typeof MemoryEntrySchema> | null> {
+    return this.memories.get(id) || null;
+  }
+
+  /**
+   * Search memories by query options
+   */
+  public async search(options: MemoryQueryOptions): Promise<z.infer<typeof MemoryEntrySchema>[]> {
+    let results = Array.from(this.memories.values());
+
+    // Apply filters
+    if (options.type) {
+      results = results.filter(m => m.type === options.type);
+    }
+
+    if (options.startTime) {
+      results = results.filter(m => m.timestamp >= options.startTime!);
+    }
+
+    if (options.endTime) {
+      results = results.filter(m => m.timestamp <= options.endTime!);
+    }
+
+    if (options.minImportance) {
+      results = results.filter(m => m.importance >= options.minImportance!);
+    }
+
+    if (options.metadata) {
+      results = results.filter(m => {
+        return Object.entries(options.metadata!).every(([key, value]) => 
+          m.metadata[key] === value
+        );
+      });
+    }
+
+    if (options.content) {
+      const searchContent = options.content.toLowerCase();
+      results = results.filter(m => 
+        m.content.toLowerCase().includes(searchContent) ||
+        searchContent.includes(m.content.toLowerCase())
+      );
+    }
+
+    // Sort by importance and timestamp
+    results.sort((a, b) => {
+      const importanceDiff = b.importance - a.importance;
+      return importanceDiff !== 0 ? importanceDiff : b.timestamp - a.timestamp;
+    });
+
+    // Apply limit
+    if (options.limit) {
+      results = results.slice(0, options.limit);
+    }
+
+    return results;
+  }
+
+  /**
+   * Update a memory
+   */
+  public async update(
+    id: string,
+    updates: Partial<z.infer<typeof MemoryEntrySchema>>
+  ): Promise<void> {
+    const memory = this.memories.get(id);
+    if (!memory) {
+      throw new Error(`Memory ${id} not found`);
+    }
+
+    Object.assign(memory, updates);
+    this.memories.set(id, memory);
+  }
+
+  /**
+   * Delete a memory
+   */
+  public async delete(id: string): Promise<void> {
+    this.memories.delete(id);
+  }
+
+  /**
+   * Clear all memories
+   */
+  public async clear(): Promise<void> {
+    this.memories.clear();
+  }
+
+  /**
+   * Consolidate memories from working memory
+   * This process involves:
+   * 1. Evaluating importance of working memories
+   * 2. Filtering out low importance memories
+   * 3. Generating embeddings for semantic search
+   * 4. Storing consolidated memories
+   */
+  public async consolidate(workingMemory: WorkingMemory): Promise<void> {
+    // Get all memories from working memory
+    const memories = await workingMemory.search({});
+
+    for (const memory of memories) {
+      // Skip if already consolidated
+      if (this.memories.has(memory.id)) {
+        continue;
+      }
+
+      // Check for similar existing memories
+      const similarMemories = await this.search({
+        content: memory.content,
+        limit: 1,
+      });
+
+      // If a very similar memory exists, update its importance instead of creating new
+      if (similarMemories.length > 0 && 
+          (similarMemories[0].content === memory.content || 
+           similarMemories[0].content.includes(memory.content) || 
+           memory.content.includes(similarMemories[0].content))) {
+        const existingMemory = similarMemories[0];
+        await this.update(existingMemory.id, {
+          importance: Math.max(existingMemory.importance, memory.importance),
+          metadata: {
+            ...existingMemory.metadata,
+            lastReinforced: Date.now(),
+          },
+        });
+        continue;
+      }
+
+      // Evaluate importance based on:
+      // - Explicit importance score
+      // - Age of memory
+      // - Number of related memories
+      const age = Date.now() - memory.timestamp;
+      const relatedMemories = await this.search({
+        content: memory.content,
+        limit: 5,
+      });
+
+      const importance = Math.min(
+        1,
+        memory.importance * 0.7 + // Base importance has higher weight
+        (relatedMemories.length * 0.1) - // Related memories boost importance
+        (age / (24 * 60 * 60 * 1000) * 0.2) // Age reduces importance more significantly
+      );
+
+      // Add new memory with updated importance
+      await this.add(memory.content, memory.type, {
+        ...memory.metadata,
+        importance,
+        originalId: memory.id,
+        consolidatedAt: Date.now(),
+      });
+    }
+
+    // Clear consolidated memories from working memory
+    await workingMemory.clear();
+  }
+
+  /**
+   * Forget old or unimportant memories
+   */
+  public async forget(options: MemoryQueryOptions): Promise<void> {
+    const memories = Array.from(this.memories.values());
+    
+    // Find memories to forget based on time and importance
+    const toForget = memories.filter(memory => {
+      // Check if memory is old enough using metadata timestamp if available
+      const timestamp = memory.metadata.timestamp ?? memory.timestamp;
+      const isOld = options.endTime ? timestamp <= options.endTime : false;
+      
+      // Check if memory is not important enough
+      const isUnimportant = options.minImportance ? memory.importance < options.minImportance : false;
+      
+      // Only forget memories that are both old and unimportant
+      return isOld && isUnimportant;
+    });
+
+    // Delete forgotten memories
+    for (const memory of toForget) {
+      await this.delete(memory.id);
+    }
+  }
+} 

package/src/memory/manager.ts

@@ -0,0 +1,160 @@
+import type { MemoryManager } from './types';
+import type { Message } from '../types/message';
+import type { z } from 'zod';
+import type { MemoryEntrySchema } from './types';
+import { WorkingMemoryImpl } from './working';
+import { LongTermMemoryImpl } from './longterm';
+
+/**
+ * Memory manager implementation for coordinating working and long-term memory
+ */
+export class MemoryManagerImpl implements MemoryManager {
+  public readonly working: WorkingMemoryImpl;
+  public readonly longTerm: LongTermMemoryImpl;
+
+  constructor() {
+    this.working = new WorkingMemoryImpl();
+    this.longTerm = new LongTermMemoryImpl();
+  }
+
+  /**
+   * Initialize memory systems
+   */
+  public async init(): Promise<void> {
+    // Initialize working memory
+    await this.working.clear();
+
+    // Initialize long-term memory
+    await this.longTerm.clear();
+  }
+
+  /**
+   * Process a message through memory systems
+   * This involves:
+   * 1. Storing the message in working memory
+   * 2. Updating importance based on context
+   * 3. Triggering consolidation if needed
+   */
+  public async processMessage(message: Message): Promise<void> {
+    // Store message in working memory
+    const memory = await this.working.add(message.content, 'message', {
+      role: message.role,
+      causedBy: message.causedBy,
+      sentFrom: message.sentFrom,
+      sendTo: Array.from(message.sendTo),
+      instructContent: message.instructContent,
+      timestamp: Date.now(),
+    });
+
+    // Update importance based on:
+    // - Message role (system > assistant > user)
+    // - Presence of instruction content
+    // - Number of recipients
+    let importance = 0.5;
+    
+    if (message.role === 'system') {
+      importance += 0.3;
+    } else if (message.role === 'assistant') {
+      importance += 0.2;
+    }
+
+    if (message.instructContent) {
+      importance += 0.1;
+    }
+
+    if (message.sendTo.size > 1) {
+      importance += 0.1;
+    }
+
+    await this.working.update(memory.id, { importance });
+
+    // Get working memory size
+    const workingMemories = await this.working.search({});
+
+    // Trigger consolidation if working memory is too large
+    if (workingMemories.length > 100) {
+      await this.longTerm.consolidate(this.working);
+    }
+  }
+
+  /**
+   * Retrieve relevant memories for context
+   */
+  public async getContext(message: Message): Promise<z.infer<typeof MemoryEntrySchema>[]> {
+    // Get recent memories from working memory (last 1 hour)
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const workingMemories = await this.working.search({
+      startTime: oneHourAgo,
+      limit: 10,
+    });
+
+    // Get relevant memories from long-term memory using content search
+    const searchTerms = message.content.toLowerCase().split(/\s+/);
+    const longTermMemories = await this.longTerm.search({
+      content: message.content,
+      minImportance: 0.2,
+      limit: 20,
+    });
+
+    // Calculate relevance scores for all memories
+    const scoredMemories = [...workingMemories, ...longTermMemories].map(memory => {
+      // Time decay factor (exponential decay over 24 hours)
+      const timeDecay = Math.exp(-(Date.now() - memory.timestamp) / (24 * 60 * 60 * 1000));
+      
+      // Content similarity (word overlap)
+      const memoryWords = memory.content.toLowerCase().split(/\s+/);
+      const overlap = searchTerms.filter(term => 
+        memoryWords.some(word => word.includes(term) || term.includes(word))
+      ).length;
+      const contentSimilarity = overlap / Math.max(searchTerms.length, memoryWords.length);
+      
+      // Combine scores with weights
+      const score = (timeDecay * 0.2) +           // Recency
+                   (memory.importance * 0.3) +     // Importance
+                   (contentSimilarity * 0.5);      // Content matching (higher weight)
+      
+      return { memory, score };
+    });
+
+    // Sort by score and return top memories
+    return scoredMemories
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 5)
+      .map(item => item.memory);
+  }
+
+  /**
+   * Calculate cosine similarity between two vectors
+   */
+  private calculateCosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) return 0;
+    
+    const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
+    const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
+    const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
+    
+    return magnitudeA && magnitudeB ? dotProduct / (magnitudeA * magnitudeB) : 0;
+  }
+
+  /**
+   * Cleanup memory systems
+   * This involves:
+   * 1. Consolidating remaining working memories
+   * 2. Forgetting old and unimportant memories
+   * 3. Clearing working memory
+   */
+  public async cleanup(): Promise<void> {
+    // Consolidate remaining working memories
+    await this.longTerm.consolidate(this.working);
+
+    // Forget old memories
+    const oneMonthAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    await this.longTerm.forget({
+      endTime: oneMonthAgo,
+      minImportance: 0.8, // Keep very important old memories
+    });
+
+    // Clear working memory
+    await this.working.clear();
+  }
+} 

package/src/memory/types.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import type { Message } from '../types/message';
+
+/**
+ * Memory entry schema for storing individual memories
+ */
+export const MemoryEntrySchema = z.object({
+  /** Unique identifier for the memory */
+  id: z.string().uuid(),
+  /** Content of the memory */
+  content: z.string(),
+  /** Type of memory (e.g., conversation, fact, experience) */
+  type: z.string(),
+  /** Creation timestamp */
+  timestamp: z.number().default(() => Date.now()),
+  /** Associated metadata */
+  metadata: z.record(z.any()).default({}),
+  /** Importance score (0-1) */
+  importance: z.number().min(0).max(1).default(0.5),
+  /** Vector embedding for similarity search */
+  embedding: z.array(z.number()).optional(),
+});
+
+/**
+ * Memory query options
+ */
+export interface MemoryQueryOptions {
+  /** Content to search for */
+  content?: string;
+  /** Type of memories to search */
+  type?: string;
+  /** Time range start */
+  startTime?: number;
+  /** Time range end */
+  endTime?: number;
+  /** Minimum importance score */
+  minImportance?: number;
+  /** Maximum number of results */
+  limit?: number;
+  /** Metadata filters */
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Memory interface for storing and retrieving memories
+ */
+export interface Memory {
+  /** Add a new memory */
+  add(content: string, type: string, metadata?: Record<string, any>): Promise<z.infer<typeof MemoryEntrySchema>>;
+  /** Get a memory by ID */
+  get(id: string): Promise<z.infer<typeof MemoryEntrySchema> | null>;
+  /** Search memories by query options */
+  search(options: MemoryQueryOptions): Promise<z.infer<typeof MemoryEntrySchema>[]>;
+  /** Update a memory */
+  update(id: string, updates: Partial<z.infer<typeof MemoryEntrySchema>>): Promise<void>;
+  /** Delete a memory */
+  delete(id: string): Promise<void>;
+  /** Clear all memories */
+  clear(): Promise<void>;
+}
+
+/**
+ * Working memory interface for temporary storage
+ */
+export interface WorkingMemory extends Memory {
+  /** Get current focus of attention */
+  getFocus(): Promise<z.infer<typeof MemoryEntrySchema> | null>;
+  /** Set focus of attention */
+  setFocus(id: string): Promise<void>;
+  /** Clear focus of attention */
+  clearFocus(): Promise<void>;
+}
+
+/**
+ * Long-term memory interface for persistent storage
+ */
+export interface LongTermMemory extends Memory {
+  /** Consolidate memories from working memory */
+  consolidate(workingMemory: WorkingMemory): Promise<void>;
+  /** Forget old or unimportant memories */
+  forget(options: MemoryQueryOptions): Promise<void>;
+}
+
+/**
+ * Memory manager interface for coordinating different memory types
+ */
+export interface MemoryManager {
+  /** Working memory instance */
+  working: WorkingMemory;
+  /** Long-term memory instance */
+  longTerm: LongTermMemory;
+  /** Initialize memory systems */
+  init(): Promise<void>;
+  /** Process a message through memory */
+  processMessage(message: Message): Promise<void>;
+  /** Retrieve relevant memories for context */
+  getContext(message: Message): Promise<z.infer<typeof MemoryEntrySchema>[]>;
+  /** Cleanup memory systems */
+  cleanup(): Promise<void>;
+}