@louloulinx/metagpt 0.1.3

package/src/actions/di/execute-nb-code.ts

@@ -0,0 +1,247 @@
+import { exec } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import type { LLMProvider } from '../../types/llm';
+
+/**
+ * 执行Notebook代码动作
+ */
+export class ExecuteNbCode {
+  private llm: LLMProvider;
+  private tempDir: string = 'temp';
+  private process: any = null;
+  private commonDependencies = ['pandas', 'numpy', 'matplotlib', 'seaborn', 'scikit-learn'];
+  
+  constructor(llm: LLMProvider) {
+    this.llm = llm;
+    console.log('[ExecuteNbCode] Initializing ExecuteNbCode');
+    
+    // Ensure temp directory exists
+    this.ensureTempDir();
+  }
+  
+  /**
+   * 确保临时目录存在
+   */
+  private async ensureTempDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.tempDir, { recursive: true });
+      console.log(`[ExecuteNbCode] Temporary directory created: ${this.tempDir}`);
+    } catch (error) {
+      console.error('[ExecuteNbCode] Error creating temporary directory:', error);
+    }
+  }
+  
+  /**
+   * 执行代码
+   */
+  async run(code: string): Promise<[string, boolean]> {
+    console.log('[ExecuteNbCode] Starting code execution');
+    console.log('[ExecuteNbCode] Code length:', code.length, 'bytes');
+    
+    try {
+      // Check for required dependencies
+      console.log('[ExecuteNbCode] Checking for required dependencies');
+      const missingDeps = await this.checkDependencies(code);
+      
+      if (missingDeps.length > 0) {
+        console.log(`[ExecuteNbCode] Missing dependencies detected: ${missingDeps.join(', ')}`);
+        const installInstructions = this.getInstallInstructions(missingDeps);
+        return [installInstructions, false];
+      }
+      
+      // Create a temporary Python file
+      const filename = `${uuidv4()}.py`;
+      const filepath = path.join(this.tempDir, filename);
+      
+      console.log(`[ExecuteNbCode] Writing code to ${filepath}`);
+      await fs.writeFile(filepath, code);
+      console.log(`[ExecuteNbCode] Code written to temporary file, size: ${(await fs.stat(filepath)).size} bytes`);
+      
+      // Execute the code
+      console.log('[ExecuteNbCode] Executing Python code');
+      const [result, success] = await this.executePython(filepath);
+      
+      // Clean up
+      try {
+        await fs.unlink(filepath);
+        console.log(`[ExecuteNbCode] Removed temporary file: ${filepath}`);
+      } catch (cleanupError) {
+        console.warn(`[ExecuteNbCode] Failed to remove temporary file: ${filepath}`, cleanupError);
+      }
+      
+      if (success) {
+        console.log(`[ExecuteNbCode] Execution successful, output length: ${result.length} bytes`);
+      } else {
+        console.error(`[ExecuteNbCode] Execution failed: ${result.substring(0, 200)}...`);
+      }
+      
+      return [result, success];
+    } catch (error) {
+      console.error('[ExecuteNbCode] Error executing code:', error);
+      return [`Error executing code: ${error}`, false];
+    }
+  }
+  
+  /**
+   * 检查代码中使用的依赖是否已安装
+   */
+  private async checkDependencies(code: string): Promise<string[]> {
+    console.log('[ExecuteNbCode] Analyzing code for import statements');
+    const importRegex = /import\s+([a-zA-Z0-9_,\s]+)(?:\s+as\s+[a-zA-Z0-9_]+)?|from\s+([a-zA-Z0-9_.]+)\s+import/g;
+    const matches = [...code.matchAll(importRegex)];
+    
+    // Extract module names
+    const moduleSet = new Set<string>();
+    for (const match of matches) {
+      if (match[1]) {
+        // import X, Y, Z
+        const modules = match[1].split(',').map(m => m.trim().split('.')[0]);
+        modules.forEach(m => moduleSet.add(m));
+      } else if (match[2]) {
+        // from X import Y
+        moduleSet.add(match[2].split('.')[0]);
+      }
+    }
+    
+    console.log(`[ExecuteNbCode] Detected modules: ${Array.from(moduleSet).join(', ')}`);
+    
+    // Check if modules are installed
+    const missingDeps: string[] = [];
+    for (const module of moduleSet) {
+      // Skip standard library modules
+      if (['os', 'sys', 'time', 'datetime', 'json', 'math', 'random', 're'].includes(module)) {
+        continue;
+      }
+      
+      // Check if module is installed
+      const isInstalled = await this.isModuleInstalled(module);
+      if (!isInstalled) {
+        missingDeps.push(module);
+      }
+    }
+    
+    return missingDeps;
+  }
+  
+  /**
+   * 检查模块是否已安装
+   */
+  private async isModuleInstalled(moduleName: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      console.log(`[ExecuteNbCode] Checking if module is installed: ${moduleName}`);
+      const command = `python -c "import ${moduleName}" 2>/dev/null`;
+      
+      exec(command, (error) => {
+        if (error) {
+          console.log(`[ExecuteNbCode] Module ${moduleName} is not installed`);
+          resolve(false);
+          return;
+        }
+        
+        console.log(`[ExecuteNbCode] Module ${moduleName} is installed`);
+        resolve(true);
+      });
+    });
+  }
+  
+  /**
+   * 获取安装说明
+   */
+  private getInstallInstructions(missingDeps: string[]): string {
+    const pipCommand = `pip install ${missingDeps.join(' ')}`;
+    
+    return `
+## Missing Dependencies Detected
+
+The following Python packages are required but not installed:
+\`\`\`
+${missingDeps.join('\n')}
+\`\`\`
+
+Please install these dependencies using pip:
+\`\`\`
+${pipCommand}
+\`\`\`
+
+After installing the dependencies, try running the analysis again.
+
+Original Python Code:
+\`\`\`python
+${this.getFirstLinesOfCode()}
+\`\`\`
+...
+`;
+  }
+  
+  /**
+   * 获取要显示的代码的前几行
+   */
+  private getFirstLinesOfCode(): string {
+    // This would typically show the first few lines of the code
+    // Since we don't have the code at this point, we'll return a placeholder
+    return "# The generated code requires additional Python packages\n# Please install them using the pip command above";
+  }
+  
+  /**
+   * 执行Python代码
+   */
+  private executePython(filepath: string): Promise<[string, boolean]> {
+    return new Promise((resolve) => {
+      const command = `python ${filepath}`;
+      
+      console.log(`[ExecuteNbCode] Running command: ${command}`);
+      
+      this.process = exec(command, (error, stdout, stderr) => {
+        if (error) {
+          console.error(`[ExecuteNbCode] Execution error: ${error.message}`);
+          
+          // Check if the error is due to missing dependencies
+          if (stderr.includes('ModuleNotFoundError: No module named')) {
+            const match = stderr.match(/ModuleNotFoundError: No module named '([^']+)'/);
+            if (match && match[1]) {
+              const missingModule = match[1];
+              const installCmd = `pip install ${missingModule}`;
+              const errorMsg = `
+## Missing Dependency: ${missingModule}
+
+Python cannot find the required module: \`${missingModule}\`
+
+Please install it using pip:
+\`\`\`
+${installCmd}
+\`\`\`
+
+After installing the dependency, try running the analysis again.
+`;
+              resolve([errorMsg, false]);
+              return;
+            }
+          }
+          
+          resolve([`Execution error: ${error.message}\n${stderr}`, false]);
+          return;
+        }
+        
+        if (stderr) {
+          console.warn(`[ExecuteNbCode] Stderr: ${stderr}`);
+        }
+        
+        console.log(`[ExecuteNbCode] Execution successful, stdout length: ${stdout.length}`);
+        resolve([stdout, true]);
+      });
+    });
+  }
+  
+  /**
+   * 终止执行
+   */
+  async terminate(): Promise<void> {
+    if (this.process) {
+      console.log('[ExecuteNbCode] Terminating process');
+      this.process.kill();
+      this.process = null;
+    }
+  }
+} 

package/src/actions/di/write-analysis-code.ts

@@ -0,0 +1,234 @@
+import { BaseAction } from '../base-action';
+import type { ActionOutput } from '../../types/action';
+import type { LLMProvider } from '../../types/llm';
+import type { Message } from '../../types/message';
+
+// Define data info prompt template
+export const DATA_INFO = `
+# Data Information
+{info}
+`;
+
+/**
+ * ActionConfig配置接口
+ */
+export interface ActionConfig {
+  name?: string;
+  description?: string;
+  args?: Record<string, any>;
+  llm: LLMProvider;
+  memory?: any;
+  workingMemory?: any;
+}
+
+/**
+ * WriteAnalysisCode配置接口
+ */
+export interface WriteAnalysisCodeConfig extends ActionConfig {
+  llm: LLMProvider;
+}
+
+/**
+ * 编写数据分析代码动作
+ */
+export class WriteAnalysisCode extends BaseAction {
+  constructor(config: WriteAnalysisCodeConfig) {
+    super({
+      ...config,
+      name: 'WriteAnalysisCode',
+    });
+    console.log('[WriteAnalysisCode] Initialized');
+  }
+
+  /**
+   * 运行动作
+   */
+  async run(): Promise<ActionOutput> {
+    try {
+      console.log('[WriteAnalysisCode] Starting run method');
+      
+      // Get arguments
+      const userRequirement = this.getArg<string>('user_requirement') || '';
+      const planStatus = this.getArg<string>('plan_status') || '';
+      const toolInfo = this.getArg<string>('tool_info') || '';
+      const workingMemory = this.getArg<Message[]>('working_memory') || [];
+      const useReflection = this.getArg<boolean>('use_reflection') || false;
+      
+      console.log(`[WriteAnalysisCode] User requirement: ${userRequirement.substring(0, 50)}...`);
+      console.log(`[WriteAnalysisCode] Use reflection: ${useReflection}`);
+      
+      // Format working memory
+      const workingMemoryText = workingMemory
+        .map(msg => `${msg.role}: ${msg.content}`)
+        .join('\n\n');
+      
+      // Generate prompt
+      const prompt = this.generateCodePrompt(
+        userRequirement,
+        workingMemoryText,
+        planStatus,
+        toolInfo,
+        useReflection
+      );
+      
+      console.log(`[WriteAnalysisCode] Generated prompt (${prompt.length} characters)`);
+      
+      // Generate code with LLM
+      console.log('[WriteAnalysisCode] Calling LLM to generate code');
+      const result = await this.llm.generate(prompt);
+      
+      // Extract Python code
+      const code = this.extractPythonCode(result);
+      console.log(`[WriteAnalysisCode] Generated code (${code.length} characters)`);
+      
+      return this.createOutput(code, 'completed');
+    } catch (error) {
+      console.error('[WriteAnalysisCode] Error generating code:', error);
+      return this.createOutput(`Error generating code: ${error}`, 'failed');
+    }
+  }
+  
+  /**
+   * 生成代码提示词
+   */
+  private generateCodePrompt(
+    userRequirement: string,
+    workingMemory: string,
+    planStatus: string = '',
+    toolInfo: string = '',
+    useReflection: boolean = false
+  ): string {
+    // Construct the prompt
+    let prompt = `# Data Analysis Task
+## User Requirement
+${userRequirement}
+
+`;
+
+    // Add working memory if available
+    if (workingMemory) {
+      prompt += `## Context and History
+${workingMemory}
+
+`;
+    }
+
+    // Add plan status if available
+    if (planStatus) {
+      prompt += `## Current Plan Status
+${planStatus}
+
+`;
+    }
+
+    // Add tool info if available
+    if (toolInfo) {
+      prompt += `## Available Tools
+${toolInfo}
+
+`;
+    }
+
+    // Reflection instructions if enabled
+    if (useReflection) {
+      prompt += `## Reflection
+Please review the previous code and execution results. Identify errors and issues, and make improvements.
+
+`;
+    }
+
+    // Final instructions
+    prompt += `## Instructions
+Please write clean, efficient Python code to analyze the data according to the user requirement.
+Use pandas, numpy, matplotlib, and other data science libraries as appropriate.
+Include comments to explain your code.
+Make sure your code is complete and executable.
+Do not include markdown annotations, just write the Python code directly.
+
+`;
+
+    return prompt;
+  }
+  
+  /**
+   * 从LLM响应中提取Python代码
+   */
+  private extractPythonCode(text: string): string {
+    // Try to extract code from markdown code blocks
+    const pythonBlockRegex = /```(?:python)?\s*([\s\S]*?)```/g;
+    const matches = text.match(pythonBlockRegex);
+    
+    if (matches && matches.length > 0) {
+      // Extract code from the first code block
+      const codeBlock = matches[0];
+      return codeBlock.replace(/```(?:python)?\s*/, '').replace(/```$/, '').trim();
+    }
+    
+    // If no code blocks found, assume the entire text is code
+    return text.trim();
+  }
+}
+
+/**
+ * CheckData配置接口
+ */
+export interface CheckDataConfig extends ActionConfig {
+  llm: LLMProvider;
+}
+
+/**
+ * 检查数据动作
+ */
+export class CheckData extends BaseAction {
+  constructor(config: CheckDataConfig) {
+    super({
+      ...config,
+      name: 'CheckData',
+    });
+    console.log('[CheckData] Initialized');
+  }
+  
+  /**
+   * 运行动作
+   */
+  async run(): Promise<ActionOutput> {
+    try {
+      console.log('[CheckData] Starting run method');
+      
+      // In a full implementation, this would need to accept a plan and
+      // create code to check the data based on the plan
+      
+      // For simplicity, we'll just return a basic data check script
+      const code = `
+import pandas as pd
+import numpy as np
+
+# Check if dataset exists
+try:
+  # Try to read a potential dataset (this is just a placeholder)
+  df = pd.read_csv('data.csv')
+  
+  # Display basic information about the dataset
+  print("Dataset Information:")
+  print(f"Shape: {df.shape}")
+  print("\\nFirst 5 rows:")
+  print(df.head())
+  print("\\nData types:")
+  print(df.dtypes)
+  print("\\nSummary statistics:")
+  print(df.describe())
+  print("\\nMissing values:")
+  print(df.isnull().sum())
+except Exception as e:
+  print(f"Error loading dataset: {e}")
+  print("No dataset available for analysis.")
+`;
+      
+      console.log('[CheckData] Generated basic data check code');
+      return this.createOutput(code, 'completed');
+    } catch (error) {
+      console.error('[CheckData] Error generating data check code:', error);
+      return this.createOutput(`Error generating data check code: ${error}`, 'failed');
+    }
+  }
+} 

package/src/actions/write-tutorial.ts

@@ -0,0 +1,232 @@
+import { z } from 'zod';
+import type { ActionOutput } from '../types/action';
+import type { LLMProvider } from '../types/llm';
+import { BaseAction } from './base-action';
+
+/**
+ * 动作配置接口
+ */
+export interface ActionConfig {
+  name?: string;
+  description?: string;
+  args?: Record<string, any>;
+  llm: LLMProvider;
+  memory?: any;
+  workingMemory?: any;
+}
+
+/**
+ * 目录结构类型定义
+ */
+export type Directory = {
+  title: string;
+  directory: Array<Record<string, string[]>>;
+};
+
+/**
+ * 目录结构模式验证
+ */
+export const DirectorySchema = z.object({
+  title: z.string(),
+  directory: z.array(z.record(z.string(), z.array(z.string()))),
+});
+
+/**
+ * 教程目录生成动作配置
+ */
+export interface WriteDirectoryConfig extends ActionConfig {
+  language?: string;
+}
+
+/**
+ * 教程目录生成动作
+ */
+export class WriteDirectory extends BaseAction {
+  language: string;
+
+  constructor(config: WriteDirectoryConfig) {
+    super({
+      ...config,
+      name: 'WriteDirectory',
+    });
+    this.language = config.language || 'Chinese';
+    console.log(`[WriteDirectory] Initialized with language: ${this.language}`);
+  }
+
+  /**
+   * 执行动作，生成教程目录结构
+   */
+  async run(): Promise<ActionOutput> {
+    try {
+      console.log('[WriteDirectory] Starting run() method');
+      const topic = this.getArg<string>('topic') || '';
+      console.log(`[WriteDirectory] Topic: "${topic}"`);
+      
+      if (!topic) {
+        console.warn('[WriteDirectory] Topic is required but not provided');
+        return this.createOutput('Topic is required', 'failed');
+      }
+
+      const prompt = this.generateDirectoryPrompt(topic);
+      console.log(`[WriteDirectory] Generated prompt (${prompt.length} characters)`);
+      console.log('[WriteDirectory] Calling LLM to generate directory structure');
+      
+      const result = await this.llm.generate(prompt);
+      console.log(`[WriteDirectory] Received response from LLM (${result.length} characters)`);
+      
+      // 解析JSON结果
+      try {
+        console.log('[WriteDirectory] Parsing LLM response as JSON');
+        const jsonStr = result.replace(/```json|```/g, '').trim();
+        console.log(`[WriteDirectory] Cleaned JSON string: ${jsonStr.substring(0, 100)}...`);
+        
+        const parsed = JSON.parse(jsonStr);
+        console.log('[WriteDirectory] JSON parsed successfully');
+        
+        const directory = DirectorySchema.parse(parsed);
+        console.log(`[WriteDirectory] Directory schema validated: ${directory.title} with ${directory.directory.length} sections`);
+        
+        return this.createOutput(
+          JSON.stringify(directory),
+          'completed',
+          directory
+        );
+      } catch (e) {
+        console.error('[WriteDirectory] Failed to parse directory structure JSON:', e);
+        console.log('[WriteDirectory] Original LLM response:', result);
+        
+        // 返回默认结构
+        const defaultDirectory: Directory = {
+          title: `Tutorial for ${topic}`,
+          directory: [
+            { "Introduction": ["Overview", "Prerequisites"] },
+            { "Main Content": ["Basic Concepts", "Advanced Usage"] },
+            { "Conclusion": ["Summary", "Next Steps"] }
+          ]
+        };
+        
+        console.log('[WriteDirectory] Using default directory structure instead');
+        return this.createOutput(
+          JSON.stringify(defaultDirectory),
+          'completed',
+          defaultDirectory
+        );
+      }
+    } catch (error) {
+      console.error('[WriteDirectory] Error generating directory:', error);
+      if (error instanceof Error) {
+        await this.handleException(error);
+      }
+      return this.createOutput(`Failed to generate directory: ${error}`, 'failed');
+    }
+  }
+
+  /**
+   * 生成目录结构的提示词
+   * @param topic 教程主题
+   * @returns 提示词
+   */
+  private generateDirectoryPrompt(topic: string): string {
+    const language = this.language === 'Chinese' ? '中文' : 'English';
+    return `请为主题"${topic}"创建一个完整的教程目录结构。目录应该结构清晰、内容全面、逻辑连贯。
+
+请使用以下JSON格式输出目录结构：
+{
+  "title": "教程标题",
+  "directory": [
+    {"第一章标题": ["1.1 小节标题", "1.2 小节标题", ...]},
+    {"第二章标题": ["2.1 小节标题", "2.2 小节标题", ...]},
+    ...
+  ]
+}
+
+请确保输出是有效的JSON格式，目录结构要反映${language}教程的完整性、系统性和专业性。`;
+  }
+}
+
+/**
+ * 教程内容生成动作配置
+ */
+export interface WriteContentConfig extends ActionConfig {
+  language?: string;
+  directory: Record<string, string[]>;
+}
+
+/**
+ * 教程内容生成动作
+ */
+export class WriteContent extends BaseAction {
+  language: string;
+  directory: Record<string, string[]>;
+
+  constructor(config: WriteContentConfig) {
+    super({
+      ...config,
+      name: 'WriteContent',
+    });
+    this.language = config.language || 'Chinese';
+    this.directory = config.directory;
+    
+    const sectionTitle = Object.keys(this.directory)[0];
+    const subsections = this.directory[sectionTitle];
+    console.log(`[WriteContent] Initialized for section "${sectionTitle}" with ${subsections.length} subsections`);
+  }
+
+  /**
+   * 执行动作，生成教程内容
+   */
+  async run(): Promise<ActionOutput> {
+    try {
+      console.log('[WriteContent] Starting run() method');
+      
+      const topic = this.getArg<string>('topic') || '';
+      console.log(`[WriteContent] Topic: "${topic}"`);
+      
+      if (!topic) {
+        console.warn('[WriteContent] Topic is required but not provided');
+        return this.createOutput('Topic is required', 'failed');
+      }
+
+      const sectionTitle = Object.keys(this.directory)[0];
+      console.log(`[WriteContent] Generating content for section: "${sectionTitle}"`);
+      
+      const prompt = this.generateContentPrompt(topic);
+      console.log(`[WriteContent] Generated prompt (${prompt.length} characters)`);
+      console.log('[WriteContent] Calling LLM to generate content');
+      
+      const result = await this.llm.generate(prompt);
+      console.log(`[WriteContent] Received response from LLM (${result.length} characters)`);
+      
+      return this.createOutput(result.trim(), 'completed');
+    } catch (error) {
+      console.error('[WriteContent] Error generating content:', error);
+      if (error instanceof Error) {
+        await this.handleException(error);
+      }
+      return this.createOutput(`Failed to generate content: ${error}`, 'failed');
+    }
+  }
+
+  /**
+   * 生成内容的提示词
+   * @param topic 教程主题
+   * @returns 提示词
+   */
+  private generateContentPrompt(topic: string): string {
+    const language = this.language === 'Chinese' ? '中文' : 'English';
+    const sectionTitle = Object.keys(this.directory)[0];
+    const subsections = this.directory[sectionTitle];
+    
+    return `请为主题"${topic}"下的"${sectionTitle}"章节编写详细内容。请包含以下小节：${subsections.join('、')}。
+
+要求：
+1. 使用${language}编写
+2. 严格遵循Markdown语法，布局整洁规范
+3. 内容应该专业、详细、通俗易懂
+4. 提供实用的信息和示例
+5. 每个小节都应该有适当的标题（使用## 和 ###）
+6. 总字数应该在1000-2000字之间
+
+请直接输出Markdown内容，不需要有额外的注释。`;
+  }
+}