@louloulinx/metagpt 0.1.3

package/src/roles/tutorial-assistant.ts

@@ -0,0 +1,217 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { BaseRole } from './base-role';
+import { WriteDirectory, WriteContent } from '../actions/write-tutorial';
+import type { Directory } from '../actions/write-tutorial';
+import type { Message, MESSAGE_ROUTE } from '../types/message';
+import type { LLMProvider } from '../types/llm';
+
+/**
+ * 教程助手配置接口
+ */
+export interface TutorialAssistantConfig {
+  llm: LLMProvider;
+  language?: string;
+  outputDir?: string;
+}
+
+/**
+ * 教程助手，输入一个句子生成Markdown格式的教程文档
+ */
+export class TutorialAssistant extends BaseRole {
+  language: string;
+  outputDir: string;
+  llm: LLMProvider;
+  
+  topic = '';
+  mainTitle = '';
+  totalContent = '';
+
+  constructor(config: TutorialAssistantConfig) {
+    super(
+      'Stitch',
+      'Tutorial Assistant',
+      'Generate tutorial documents',
+      'Strictly follow Markdown\'s syntax, with neat and standardized layout',
+      []
+    );
+    
+    console.log('[TutorialAssistant] Initializing with config:', {
+      language: config.language || 'Chinese',
+      outputDir: config.outputDir || path.join(process.cwd(), 'tutorials')
+    });
+    
+    this.language = config.language || 'Chinese';
+    this.outputDir = config.outputDir || path.join(process.cwd(), 'tutorials');
+    this.llm = config.llm;
+    
+    // 初始化动作
+    this.initializeActions();
+  }
+
+  /**
+   * 初始化动作列表
+   */
+  private initializeActions(): void {
+    console.log('[TutorialAssistant] Initializing actions');
+    
+    // 初始时只设置目录生成动作
+    const writeDirectory = new WriteDirectory({
+      llm: this.llm,
+      language: this.language,
+    });
+    
+    console.log('[TutorialAssistant] Created WriteDirectory action');
+    this.actions = [writeDirectory];
+  }
+
+  /**
+   * 处理目录结构
+   * @param directory 目录结构
+   */
+  private async handleDirectory(directory: Directory): Promise<void> {
+    console.log('[TutorialAssistant] Handling directory structure:', JSON.stringify(directory, null, 2));
+    
+    this.mainTitle = directory.title;
+    this.totalContent += `# ${this.mainTitle}\n\n`;
+    
+    // 将所有章节内容生成动作添加到动作列表
+    const actions = [...this.actions];
+    
+    console.log(`[TutorialAssistant] Processing ${directory.directory.length} sections`);
+    
+    for (const section of directory.directory) {
+      const sectionKey = Object.keys(section)[0];
+      console.log(`[TutorialAssistant] Creating WriteContent action for section: ${sectionKey}`);
+      
+      const writeContent = new WriteContent({
+        llm: this.llm,
+        language: this.language,
+        directory: section,
+      });
+      
+      actions.push(writeContent);
+    }
+    
+    console.log(`[TutorialAssistant] Updated actions list, now contains ${actions.length} actions`);
+    this.actions = actions;
+  }
+
+  /**
+   * 处理消息
+   * @param message 输入消息
+   * @returns 处理结果
+   */
+  async react(message: Message): Promise<Message> {
+    console.log('[TutorialAssistant] Starting react method with message:', message.content);
+    
+    try {
+      // 保存主题
+      this.topic = message.content;
+      console.log(`[TutorialAssistant] Set topic: "${this.topic}"`);
+      
+      // 执行所有动作
+      console.log(`[TutorialAssistant] Starting execution of ${this.actions.length} actions`);
+      
+      for (let i = 0; i < this.actions.length; i++) {
+        const action = this.actions[i];
+        console.log(`[TutorialAssistant] Running action ${i+1}/${this.actions.length}: ${action.constructor.name}`);
+        
+        // 为动作设置主题参数
+        if ('setArg' in action && typeof action.setArg === 'function') {
+          console.log(`[TutorialAssistant] Setting topic argument for action: "${this.topic}"`);
+          action.setArg('topic', this.topic);
+        }
+        
+        // 执行动作
+        console.log(`[TutorialAssistant] Executing action ${action.constructor.name}`);
+        const result = await action.run();
+        console.log(`[TutorialAssistant] Action ${action.constructor.name} completed with status: ${result.status}`);
+        
+        if (result.status === 'failed') {
+          console.error(`[TutorialAssistant] Action failed: ${result.content}`);
+          return this.createMessage(`Failed to generate tutorial: ${result.content}`);
+        }
+        
+        // 处理目录生成结果
+        if (action instanceof WriteDirectory) {
+          console.log('[TutorialAssistant] Processing WriteDirectory result');
+          if (result.instructContent) {
+            console.log('[TutorialAssistant] Directory structure generated, handling it');
+            await this.handleDirectory(result.instructContent as Directory);
+          } else {
+            console.warn('[TutorialAssistant] WriteDirectory action did not produce instructContent');
+          }
+        } 
+        // 处理内容生成结果
+        else if (action instanceof WriteContent) {
+          console.log('[TutorialAssistant] Processing WriteContent result');
+          if (this.totalContent.length > 0) {
+            this.totalContent += '\n\n\n';
+          }
+          console.log(`[TutorialAssistant] Adding content (${result.content.length} characters)`);
+          this.totalContent += result.content;
+        }
+      }
+      
+      // 保存生成的内容到文件
+      console.log('[TutorialAssistant] All actions completed, saving content to file');
+      const filePath = await this.saveToFile();
+      console.log(`[TutorialAssistant] Content saved to ${filePath}`);
+      
+      return this.createMessage(`Tutorial generated successfully and saved to ${filePath}`);
+    } catch (error) {
+      console.error('[TutorialAssistant] Error in react method:', error);
+      return this.createMessage(`Error generating tutorial: ${error}`);
+    }
+  }
+
+  /**
+   * 创建消息对象
+   * @param content 消息内容
+   * @returns 消息对象
+   */
+  private createMessage(content: string): Message {
+    console.log(`[TutorialAssistant] Creating message: ${content}`);
+    return {
+      id: uuidv4(),
+      content,
+      role: this.profile,
+      causedBy: 'TutorialAssistant',
+      sentFrom: this.name,
+      sendTo: new Set(['*']),
+      instructContent: null,
+    };
+  }
+
+  /**
+   * 保存内容到文件
+   * @returns 文件路径
+   */
+  private async saveToFile(): Promise<string> {
+    try {
+      console.log(`[TutorialAssistant] Saving content (${this.totalContent.length} characters) to file`);
+      
+      // 确保输出目录存在
+      console.log(`[TutorialAssistant] Creating output directory: ${this.outputDir}`);
+      await fs.mkdir(this.outputDir, { recursive: true });
+      
+      // 生成带时间戳的文件名
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const fileName = `${this.mainTitle || 'Tutorial'}_${timestamp}.md`;
+      const filePath = path.join(this.outputDir, fileName);
+      
+      console.log(`[TutorialAssistant] Writing to file: ${filePath}`);
+      
+      // 写入文件
+      await fs.writeFile(filePath, this.totalContent);
+      console.log(`[TutorialAssistant] File written successfully: ${filePath}`);
+      
+      return filePath;
+    } catch (error) {
+      console.error('[TutorialAssistant] Error saving tutorial file:', error);
+      throw error;
+    }
+  }
+} 

package/src/skills/base-skill.ts

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import type { Skill, SkillConfig, SkillContext, SkillResult } from '../types/skill';
+import type { Action } from '../types/action';
+import type { LLMProvider } from '../types/llm';
+import { SkillContextSchema, SkillResultSchema } from '../types/skill';
+
+/**
+ * 技能基类
+ * 提供技能系统的基础功能实现
+ */
+export abstract class BaseSkill implements Skill {
+  name: string;
+  description: string;
+  context: SkillContext;
+  llm: LLMProvider;
+  actions: Action[];
+
+  constructor(config: SkillConfig) {
+    // 验证配置
+    const validConfig = z.object({
+      name: z.string(),
+      description: z.string(),
+      llm: z.any(),
+      actions: z.array(z.any()).optional(),
+      args: z.record(z.any()).optional(),
+    }).parse(config);
+
+    this.name = validConfig.name;
+    this.description = validConfig.description;
+    this.llm = validConfig.llm;
+    this.actions = validConfig.actions || [];
+
+    // 构建上下文
+    this.context = SkillContextSchema.parse({
+      name: validConfig.name,
+      description: validConfig.description,
+      actions: this.actions,
+      args: validConfig.args || {},
+      llm: validConfig.llm,
+    });
+  }
+
+  /**
+   * 执行技能
+   * 子类必须实现此方法
+   */
+  abstract execute(args?: Record<string, any>): Promise<SkillResult>;
+
+  /**
+   * 验证技能是否可用
+   * 子类可以覆盖此方法以提供自定义验证
+   */
+  async validate(): Promise<boolean> {
+    return this.actions.length > 0;
+  }
+
+  /**
+   * 处理技能执行异常
+   * @param error 错误对象
+   */
+  async handleError(error: Error): Promise<void> {
+    console.error(`Skill ${this.name} failed:`, error);
+    // 子类可以覆盖此方法以提供自定义错误处理
+  }
+
+  /**
+   * 创建技能执行结果
+   * @param success 是否成功
+   * @param message 结果消息
+   * @param data 结果数据
+   * @param error 错误信息
+   */
+  protected createResult(
+    success: boolean,
+    message: string,
+    data?: any,
+    error?: any
+  ): SkillResult {
+    return SkillResultSchema.parse({
+      success,
+      message,
+      data,
+      error,
+    });
+  }
+
+  /**
+   * 获取技能参数
+   * @param key 参数键
+   * @returns 参数值
+   */
+  protected getArg<T>(key: string): T | undefined {
+    return this.context.args?.[key] as T;
+  }
+
+  /**
+   * 设置技能参数
+   * @param key 参数键
+   * @param value 参数值
+   */
+  protected setArg<T>(key: string, value: T): void {
+    if (!this.context.args) {
+      this.context.args = {};
+    }
+    this.context.args[key] = value;
+  }
+
+  /**
+   * 执行动作序列
+   * @param actions 要执行的动作
+   * @returns 执行结果
+   */
+  protected async executeActions(actions: Action[]): Promise<SkillResult> {
+    try {
+      const results = [];
+      for (const action of actions) {
+        const result = await action.run();
+        results.push(result);
+        
+        if (result.status === 'failed') {
+          return this.createResult(
+            false,
+            `Action ${action.name} failed: ${result.content}`,
+            results
+          );
+        }
+      }
+      
+      return this.createResult(
+        true,
+        'All actions completed successfully',
+        results
+      );
+    } catch (error) {
+      await this.handleError(error as Error);
+      return this.createResult(
+        false,
+        `Failed to execute actions: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+} 

package/src/skills/code-review.ts

@@ -0,0 +1,120 @@
+import { BaseSkill } from './base-skill';
+import { AnalyzeTask } from '../actions/analyze-task';
+import type { SkillConfig, SkillResult } from '../types/skill';
+import type { ActionOutput } from '../types/action';
+
+/**
+ * 代码审查技能
+ * 使用 LLM 进行代码审查并提供改进建议
+ */
+export class CodeReviewSkill extends BaseSkill {
+  constructor(config: SkillConfig) {
+    super({
+      ...config,
+      name: 'code_review',
+      description: 'Review code and provide improvement suggestions',
+    });
+
+    // 添加代码分析动作
+    this.actions.push(
+      new AnalyzeTask({
+        name: 'analyze_code',
+        description: 'Analyze code structure and quality',
+        llm: this.llm,
+      })
+    );
+  }
+
+  /**
+   * 执行代码审查
+   * @param args 执行参数
+   * @returns 审查结果
+   */
+  async execute(args?: Record<string, any>): Promise<SkillResult> {
+    try {
+      // 验证输入
+      if (!args?.code) {
+        return this.createResult(false, 'No code provided for review');
+      }
+
+      // 设置分析参数
+      this.actions[0].context.args = {
+        task: `Review the following code and provide improvement suggestions:
+${args.code}
+
+Please analyze:
+1. Code structure and organization
+2. Potential bugs or issues
+3. Performance considerations
+4. Best practices compliance
+5. Suggested improvements
+
+Please provide specific examples and explanations for each point.`,
+      };
+
+      // 执行代码分析
+      const result = await this.executeActions(this.actions);
+      if (!result.success) {
+        return result;
+      }
+
+      // 处理分析结果
+      const analysisResults = result.data as ActionOutput[];
+      const analysis = analysisResults[0].content;
+
+      return this.createResult(
+        true,
+        'Code review completed successfully',
+        {
+          analysis,
+          suggestions: this.extractSuggestions(analysis),
+        }
+      );
+    } catch (error) {
+      await this.handleError(error as Error);
+      return this.createResult(
+        false,
+        `Code review failed: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 从分析结果中提取建议
+   * @param analysis 分析结果文本
+   * @returns 建议列表
+   */
+  private extractSuggestions(analysis: string): string[] {
+    const suggestions: string[] = [];
+    const lines = analysis.split('\n');
+
+    let inSuggestionSection = false;
+    for (const line of lines) {
+      if (line.toLowerCase().includes('suggested improvements')) {
+        inSuggestionSection = true;
+        continue;
+      }
+
+      if (inSuggestionSection && line.trim()) {
+        // 移除序号和点号
+        const suggestion = line.replace(/^\d+[.)][ \t]*/, '').trim();
+        if (suggestion) {
+          suggestions.push(suggestion);
+        }
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * 自定义错误处理
+   */
+  async handleError(error: Error): Promise<void> {
+    await super.handleError(error);
+    this.setArg('lastError', error.message);
+    // 可以添加特定的错误处理逻辑，如通知代码作者等
+  }
+} 

package/src/tools/base-tool.ts

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+import type { Tool, ToolConfig, ToolContext, ToolResult } from '../types/tool';
+import { ToolContextSchema, ToolResultSchema } from '../types/tool';
+
+/**
+ * 工具基类
+ * 提供工具系统的基础功能实现
+ */
+export abstract class BaseTool implements Tool {
+  name: string;
+  description: string;
+  version: string;
+  category: string;
+  context: ToolContext;
+
+  constructor(config: ToolConfig) {
+    // 验证配置
+    const validConfig = z.object({
+      name: z.string(),
+      description: z.string(),
+      version: z.string(),
+      category: z.string(),
+      args: z.record(z.any()).optional(),
+      metadata: z.record(z.any()).optional(),
+    }).parse(config);
+
+    this.name = validConfig.name;
+    this.description = validConfig.description;
+    this.version = validConfig.version;
+    this.category = validConfig.category;
+
+    // 构建上下文
+    this.context = ToolContextSchema.parse({
+      name: validConfig.name,
+      description: validConfig.description,
+      args: validConfig.args || {},
+      metadata: validConfig.metadata || {},
+      state: {},
+    });
+  }
+
+  /**
+   * 执行工具
+   * 子类必须实现此方法
+   */
+  abstract execute(args?: Record<string, any>): Promise<ToolResult>;
+
+  /**
+   * 验证工具是否可用
+   * 子类可以覆盖此方法以提供自定义验证
+   */
+  async validate(): Promise<boolean> {
+    return true;
+  }
+
+  /**
+   * 处理工具执行异常
+   * @param error 错误对象
+   */
+  async handleError(error: Error): Promise<void> {
+    console.error(`Tool ${this.name} failed:`, error);
+    // 子类可以覆盖此方法以提供自定义错误处理
+  }
+
+  /**
+   * 获取工具帮助信息
+   * 子类可以覆盖此方法以提供更详细的帮助信息
+   */
+  getHelp(): string {
+    return `
+Tool: ${this.name} (v${this.version})
+Category: ${this.category}
+Description: ${this.description}
+
+Arguments:
+${this.formatArgs()}
+    `.trim();
+  }
+
+  /**
+   * 创建工具执行结果
+   * @param success 是否成功
+   * @param message 结果消息
+   * @param data 结果数据
+   * @param error 错误信息
+   * @param metadata 结果元数据
+   */
+  protected createResult(
+    success: boolean,
+    message: string,
+    data?: any,
+    error?: any,
+    metadata?: Record<string, any>
+  ): ToolResult {
+    return ToolResultSchema.parse({
+      success,
+      message,
+      data,
+      error,
+      metadata,
+    });
+  }
+
+  /**
+   * 获取工具参数
+   * @param key 参数键
+   * @returns 参数值
+   */
+  protected getArg<T>(key: string): T | undefined {
+    return this.context.args?.[key] as T;
+  }
+
+  /**
+   * 设置工具参数
+   * @param key 参数键
+   * @param value 参数值
+   */
+  protected setArg<T>(key: string, value: T): void {
+    if (!this.context.args) {
+      this.context.args = {};
+    }
+    this.context.args[key] = value;
+  }
+
+  /**
+   * 获取工具状态
+   * @param key 状态键
+   * @returns 状态值
+   */
+  protected getState<T>(key: string): T | undefined {
+    return this.context.state?.[key] as T;
+  }
+
+  /**
+   * 设置工具状态
+   * @param key 状态键
+   * @param value 状态值
+   */
+  protected setState<T>(key: string, value: T): void {
+    if (!this.context.state) {
+      this.context.state = {};
+    }
+    this.context.state[key] = value;
+  }
+
+  /**
+   * 格式化参数说明
+   */
+  private formatArgs(): string {
+    const args = this.context.args || {};
+    return Object.entries(args)
+      .map(([key, value]) => `- ${key}: ${typeof value}`)
+      .join('\n');
+  }
+}