@louloulinx/metagpt 0.1.3

package/src/roles/base-role.ts

@@ -0,0 +1,155 @@
+import { interpret, createActor } from 'xstate';
+import { Subject } from 'rxjs';
+import type { Role, RoleContext } from '../types/role';
+import type { Message } from '../types/message';
+import type { Action } from '../types/action';
+import { roleStateMachine } from '../types/role';
+import { ArrayMemory } from '../types/memory';
+import { generateId } from '../utils/common';
+
+/**
+ * 角色基类
+ * 实现了基本的角色行为和状态管理
+ */
+export abstract class BaseRole implements Role {
+  name: string;
+  profile: string;
+  goal: string;
+  constraints: string;
+  actions: Action[] = [];
+  state = -1;
+  context: RoleContext;
+
+  // 消息流
+  private messageSubject = new Subject<Message>();
+
+  // 状态机
+  private stateMachine = createActor(roleStateMachine).start();
+
+  constructor(
+    name: string,
+    profile: string,
+    goal: string,
+    constraints: string = '',
+    actions: Action[] = []
+  ) {
+    this.name = name;
+    this.profile = profile;
+    this.goal = goal;
+    this.constraints = constraints;
+    this.actions = actions;
+
+    // 初始化上下文
+    this.context = {
+      memory: new ArrayMemory(),
+      workingMemory: new ArrayMemory(),
+      state: -1,
+      todo: null,
+      watch: new Set<string>(),
+      reactMode: 'react',
+    };
+
+    // 订阅状态变化
+    this.stateMachine.subscribe((state) => {
+      this.state = this.stateToNumber(state.value as string);
+    });
+
+    // 订阅消息
+    this.messageSubject.subscribe((message) => {
+      this.context.memory.add(message);
+    });
+  }
+
+  /**
+   * 观察环境，获取下一个状态
+   */
+  async observe(): Promise<number> {
+    this.stateMachine.send({ type: 'OBSERVE' });
+    const messages = await this.context.memory.get();
+    // 子类需要实现具体的观察逻辑
+    return this.state;
+  }
+
+  /**
+   * 思考下一步行动
+   */
+  async think(): Promise<boolean> {
+    this.stateMachine.send({ type: 'THINK' });
+    // 子类需要实现具体的思考逻辑
+    return true;
+  }
+
+  /**
+   * 执行行动
+   */
+  async act(): Promise<Message> {
+    this.stateMachine.send({ type: 'ACT' });
+    if (!this.context.todo) {
+      throw new Error('No action to execute');
+    }
+
+    try {
+      const output = await this.context.todo.run();
+      const message: Message = {
+        id: generateId(),
+        content: output.content,
+        role: this.name,
+        causedBy: this.context.todo.name,
+        sentFrom: this.name,
+        sendTo: new Set(['*']),
+        instructContent: output.instruct_content,
+      };
+
+      this.messageSubject.next(message);
+      return message;
+    } catch (error) {
+      await this.context.todo.handleException(error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * 角色对消息的响应
+   */
+  async react(message?: Message): Promise<Message> {
+    console.log(`[BaseRole] react method called in ${this.name} with${message ? '' : 'out'} message`);
+    this.stateMachine.send({ type: 'REACT' });
+    // 子类需要实现具体的响应逻辑
+    return this.act();
+  }
+
+  /**
+   * 将状态字符串转换为数字
+   */
+  private stateToNumber(state: string): number {
+    const stateMap: Record<string, number> = {
+      idle: -1,
+      observing: 0,
+      thinking: 1,
+      acting: 2,
+      reacting: 3,
+    };
+    return stateMap[state] ?? -1;
+  }
+
+  /**
+   * 设置要执行的动作
+   */
+  protected setTodo(action: Action | null): void {
+    this.context.todo = action;
+  }
+
+  /**
+   * 获取记忆中的重要消息
+   */
+  protected getImportantMemory(): Message[] {
+    return this.context.memory.getByActions(this.context.watch);
+  }
+
+  /**
+   * 发送消息
+   */
+  protected sendMessage(message: Message): void {
+    this.messageSubject.next(message);
+  }
+} 

package/src/roles/data-interpreter.ts

@@ -0,0 +1,360 @@
+import { v4 as uuidv4 } from 'uuid';
+import { BaseRole } from './base-role';
+import { ExecuteNbCode } from '../actions/di/execute-nb-code';
+import { WriteAnalysisCode, CheckData } from '../actions/di/write-analysis-code';
+import type { ActionConfig } from '../actions/di/write-analysis-code';
+import type { Message } from '../types/message';
+import type { LLMProvider } from '../types/llm';
+import type { Action } from '../types/action';
+import { BM25ToolRecommender } from '../tools/tool-recommend';
+import type { ToolRecommender } from '../tools/tool-recommend';
+import { ArrayMemory } from '../types/memory';
+import type { Task, TaskResult } from '../types/task';
+
+/**
+ * 思考提示词
+ */
+const REACT_THINK_PROMPT = `
+# User Requirement
+{user_requirement}
+# Context
+{context}
+
+Output a json following the format:
+\`\`\`json
+{
+    "thoughts": str = "Thoughts on current situation, reflect on how you should proceed to fulfill the user requirement",
+    "state": bool = "Decide whether you need to take more actions to complete the user requirement. Return true if you think so. Return false if you think the requirement has been completely fulfilled."
+}
+\`\`\`
+`;
+
+/**
+ * 数据解释器配置接口
+ */
+export interface DataInterpreterConfig {
+  llm: LLMProvider;
+  auto_run?: boolean;
+  use_plan?: boolean;
+  use_reflection?: boolean;
+  tools?: string[];
+  react_mode?: 'plan_and_act' | 'react';
+  max_react_loop?: number;
+}
+
+/**
+ * 数据解释器角色，用于数据分析和可视化
+ */
+export class DataInterpreter extends BaseRole {
+  llm: LLMProvider;
+  auto_run: boolean;
+  use_plan: boolean;
+  use_reflection: boolean;
+  execute_code: ExecuteNbCode;
+  tools: string[] = [];
+  tool_recommender: any = null;
+  react_mode: 'plan_and_act' | 'react';
+  max_react_loop: number;
+  planner: any = null; // This would be replaced with actual Planner type
+
+  /**
+   * 构造函数
+   */
+  constructor(config: DataInterpreterConfig) {
+    super(
+      'David',
+      'DataInterpreter',
+      'Analyze data and provide insights through code generation and execution',
+      'Write clean, efficient, and well-documented code for data analysis',
+      []
+    );
+    
+    console.log('[DataInterpreter] Initializing with config:', {
+      auto_run: config.auto_run ?? true,
+      use_plan: config.use_plan ?? true,
+      use_reflection: config.use_reflection ?? false,
+      react_mode: config.react_mode ?? 'plan_and_act',
+      max_react_loop: config.max_react_loop ?? 10,
+      tools: config.tools?.length ?? 0,
+    });
+    
+    this.llm = config.llm;
+    this.auto_run = config.auto_run ?? true;
+    this.use_plan = config.use_plan ?? true;
+    this.use_reflection = config.use_reflection ?? false;
+    this.execute_code = new ExecuteNbCode(this.llm);
+    this.tools = config.tools ?? [];
+    this.react_mode = config.react_mode ?? 'plan_and_act';
+    this.max_react_loop = config.max_react_loop ?? 10;
+    
+    // Initialize tool recommender if tools are provided
+    if (this.tools.length > 0) {
+      this.tool_recommender = new BM25ToolRecommender(this.tools);
+    }
+    
+    // Initialize actions
+    this.initialize();
+  }
+  
+  /**
+   * 初始化角色
+   */
+  private initialize(): void {
+    console.log('[DataInterpreter] Initializing role');
+    
+    // Set react mode and working memory
+    this.setReactMode(this.react_mode, this.max_react_loop, this.auto_run);
+    
+    // Override use_plan based on react_mode for consistency
+    this.use_plan = this.react_mode === 'plan_and_act';
+    
+    // Set initial action
+    this.actions = [new WriteAnalysisCode({ llm: this.llm })];
+    
+    // Set initial state
+    this.context.state = 0;
+    this.setTodo(this.actions[0]);
+    
+    console.log('[DataInterpreter] Initialization complete');
+  }
+  
+  /**
+   * 设置反应模式
+   */
+  private setReactMode(mode: 'plan_and_act' | 'react', maxLoop: number, autoRun: boolean): void {
+    this.react_mode = mode;
+    
+    if (mode === 'react') {
+      this.context.reactMode = 'react';
+      this.max_react_loop = maxLoop;
+    } else {
+      this.context.reactMode = 'plan_and_act';
+      // Initialize planner here (simplified)
+      // In a full implementation, we would instantiate a proper Planner class
+      this.planner = {
+        plan: { 
+          tasks: [], 
+          get_finished_tasks: () => [], 
+          current_task: null,
+          get_plan_status: () => ""
+        },
+        ask_review: async () => ["", false],
+        set_working_memory: (wm: any) => {}
+      };
+      
+      if (!this.context.workingMemory) {
+        this.context.workingMemory = new ArrayMemory();
+      }
+      
+      // Connect planner with working memory
+      if (this.planner && this.planner.set_working_memory) {
+        this.planner.set_working_memory(this.context.workingMemory);
+      }
+    }
+  }
+  
+  /**
+   * 获取工作记忆
+   */
+  get working_memory(): ArrayMemory {
+    return this.context.workingMemory;
+  }
+  
+  /**
+   * 思考下一步行动（React 模式下使用）
+   */
+  async think(): Promise<boolean> {
+    console.log('[DataInterpreter] Starting think method');
+    
+    // Get user requirement and context
+    const memories = await this.context.memory.get();
+    if (!memories || memories.length === 0) {
+      console.warn('[DataInterpreter] No memories available');
+      return false;
+    }
+    
+    const user_requirement = memories[0].content;
+    const context = this.working_memory ? await this.working_memory.get() : [];
+    
+    if (!context || context.length === 0) {
+      // Just started the run, we need action certainly
+      console.log('[DataInterpreter] No context available, adding user requirement to working memory');
+      if (this.working_memory) {
+        this.working_memory.add(memories[0]);
+      }
+      this.context.state = 0;
+      this.setTodo(this.actions[0]);
+      return true;
+    }
+    
+    // Format context for prompt
+    const contextText = context.map(msg => `${msg.role}: ${msg.content}`).join('\n\n');
+    
+    // Create thinking prompt
+    const prompt = REACT_THINK_PROMPT
+      .replace('{user_requirement}', user_requirement)
+      .replace('{context}', contextText);
+    
+    console.log('[DataInterpreter] Sending think prompt to LLM');
+    
+    // Get LLM response
+    const response = await this.llm.generate(prompt);
+    console.log(`[DataInterpreter] Received LLM response: ${response.substring(0, 100)}...`);
+    
+    // Parse JSON response
+    try {
+      const jsonStr = response.replace(/```json|```/g, '').trim();
+      const responseObj = JSON.parse(jsonStr);
+      
+      // Add thoughts to working memory
+      if (this.working_memory) {
+        this.working_memory.add({
+          id: uuidv4(),
+          content: responseObj.thoughts,
+          role: 'assistant',
+          causedBy: 'think',
+          sentFrom: this.name,
+          sendTo: new Set(['*']),
+          instructContent: null
+        });
+      }
+      
+      // Set state based on whether more action is needed
+      const needAction = responseObj.state;
+      this.context.state = needAction ? 0 : -1;
+      if (needAction) {
+        this.setTodo(this.actions[0]);
+      } else {
+        this.setTodo(null);
+      }
+      
+      console.log(`[DataInterpreter] Think result: need further action = ${needAction}`);
+      return needAction;
+    } catch (error) {
+      console.error('[DataInterpreter] Error parsing LLM response:', error);
+      // Default to taking action if parsing fails
+      this.context.state = 0;
+      this.setTodo(this.actions[0]);
+      return true;
+    }
+  }
+  
+  /**
+   * 执行行动（React 模式下使用）
+   */
+  async act(): Promise<Message> {
+    console.log('[DataInterpreter] Starting act method');
+    
+    const [code, result, isSuccess] = await this.writeAndExecCode();
+    
+    const message: Message = {
+      id: uuidv4(),
+      content: code,
+      role: 'assistant',
+      causedBy: 'WriteAnalysisCode',
+      sentFrom: this.name,
+      sendTo: new Set(['*']),
+      instructContent: null
+    };
+    
+    console.log('[DataInterpreter] Act completed, returning message');
+    return message;
+  }
+  
+  /**
+   * 基于计划执行行动（plan_and_act 模式下使用）
+   */
+  async planAndAct(): Promise<Message> {
+    console.log('[DataInterpreter] Starting planAndAct method');
+    
+    try {
+      // This would be replaced with actual implementation
+      // that interacts with a proper Planner class
+      const message = await this.act();
+      await this.execute_code.terminate();
+      return message;
+    } catch (error) {
+      console.error('[DataInterpreter] Error in planAndAct:', error);
+      await this.execute_code.terminate();
+      throw error;
+    }
+  }
+  
+  /**
+   * 执行特定任务（plan_and_act 模式下使用）
+   */
+  async actOnTask(task: Task): Promise<TaskResult> {
+    console.log(`[DataInterpreter] Starting actOnTask with task: ${task.title}`);
+    
+    const [code, result, isSuccess] = await this.writeAndExecCode();
+    
+    const taskResult: TaskResult = {
+      code: code,
+      result: result,
+      isSuccess: isSuccess
+    };
+    
+    console.log(`[DataInterpreter] Task completed with success: ${isSuccess}`);
+    return taskResult;
+  }
+  
+  /**
+   * 编写并执行代码
+   */
+  private async writeAndExecCode(maxRetry: number = 3): Promise<[string, string, boolean]> {
+    console.log(`[DataInterpreter] Starting writeAndExecCode with max retries: ${maxRetry}`);
+    
+    let counter = 0;
+    let success = false;
+    let code = '';
+    let result = '';
+    
+    // Prepare plan status
+    const planStatus = this.use_plan && this.planner ? this.planner.get_plan_status() : '';
+    
+    // Prepare tool info
+    let toolInfo = '';
+    if (this.tool_recommender) {
+      const context = this.working_memory && this.working_memory.get().length > 0 
+        ? this.working_memory.get()[this.working_memory.get().length - 1].content 
+        : '';
+      const plan = this.use_plan && this.planner ? this.planner.plan : null;
+      
+      toolInfo = await this.tool_recommender.getRecommendedToolInfo(context, plan);
+    }
+    
+    // Check data (in a full implementation, this would interact with actual data)
+    await this.checkData();
+    
+    // Try to write and execute code, with retries
+    while (!success && counter < maxRetry) {
+      console.log(`[DataInterpreter] Code execution attempt ${counter + 1} of ${maxRetry}`);
+      
+      // Write code
+      [code] = await this.writeCode(counter, planStatus, toolInfo);
+      
+      // Add code to working memory
+      if (this.working_memory) {
+        this.working_memory.add({
+          id: uuidv4(),
+          content: code,
+          role: 'assistant',
+          causedBy: 'WriteAnalysisCode',
+          sentFrom: this.name,
+          sendTo: new Set(['*']),
+          instructContent: null
+        });
+      }
+      
+      // Execute code
+      [result, success] = await this.execute_code.run(code);
+      console.log(`Execution result: ${success ? 'Success' : 'Failed'}`);
+      
+      if (!success) {
+        console.log(`[DataInterpreter] Code execution failed, retrying...`);
+      }
+    }
+    
+    return [code, result, success];
+  }
+}

package/src/roles/engineer.ts

@@ -0,0 +1 @@
+