@louloulinx/metagpt 0.1.3

package/src/tools/file-system.ts

@@ -0,0 +1,204 @@
+import { BaseTool } from './base-tool';
+import type { ToolConfig, ToolResult } from '../types/tool';
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * 文件系统工具
+ * 提供基本的文件操作功能
+ */
+export class FileSystemTool extends BaseTool {
+  constructor(config?: Partial<ToolConfig>) {
+    super({
+      name: 'file_system',
+      description: 'Basic file system operations',
+      version: '1.0.0',
+      category: 'system',
+      ...config,
+    });
+  }
+
+  /**
+   * 执行文件系统操作
+   * @param args 执行参数
+   * @returns 执行结果
+   */
+  async execute(args?: Record<string, any>): Promise<ToolResult> {
+    try {
+      // 验证操作类型
+      const operation = args?.operation;
+      if (!operation) {
+        return this.createResult(false, 'No operation specified');
+      }
+
+      // 执行相应的操作
+      switch (operation) {
+        case 'read':
+          return await this.readFile(args);
+        case 'write':
+          return await this.writeFile(args);
+        case 'delete':
+          return await this.deleteFile(args);
+        case 'list':
+          return await this.listDirectory(args);
+        default:
+          return this.createResult(false, `Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      await this.handleError(error as Error);
+      return this.createResult(
+        false,
+        `File system operation failed: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 读取文件
+   * @param args 参数
+   * @returns 执行结果
+   */
+  private async readFile(args: Record<string, any>): Promise<ToolResult> {
+    const path = args.path;
+    if (!path) {
+      return this.createResult(false, 'No file path provided');
+    }
+
+    try {
+      const content = await fs.readFile(path, 'utf-8');
+      return this.createResult(true, 'File read successfully', { content });
+    } catch (error) {
+      return this.createResult(
+        false,
+        `Failed to read file: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 写入文件
+   * @param args 参数
+   * @returns 执行结果
+   */
+  private async writeFile(args: Record<string, any>): Promise<ToolResult> {
+    const { path, content } = args;
+    if (!path || content === undefined) {
+      return this.createResult(false, 'Path and content are required');
+    }
+
+    try {
+      // 确保目录存在
+      await fs.mkdir(dirname(path), { recursive: true });
+      await fs.writeFile(path, content);
+      return this.createResult(true, 'File written successfully');
+    } catch (error) {
+      return this.createResult(
+        false,
+        `Failed to write file: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 删除文件
+   * @param args 参数
+   * @returns 执行结果
+   */
+  private async deleteFile(args: Record<string, any>): Promise<ToolResult> {
+    const path = args.path;
+    if (!path) {
+      return this.createResult(false, 'No file path provided');
+    }
+
+    try {
+      await fs.unlink(path);
+      return this.createResult(true, 'File deleted successfully');
+    } catch (error) {
+      return this.createResult(
+        false,
+        `Failed to delete file: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 列出目录内容
+   * @param args 参数
+   * @returns 执行结果
+   */
+  private async listDirectory(args: Record<string, any>): Promise<ToolResult> {
+    const path = args.path || '.';
+
+    try {
+      const entries = await fs.readdir(path, { withFileTypes: true });
+      const files = entries.map(entry => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        path: join(path, entry.name),
+      }));
+
+      return this.createResult(true, 'Directory listed successfully', { files });
+    } catch (error) {
+      return this.createResult(
+        false,
+        `Failed to list directory: ${(error as Error).message}`,
+        undefined,
+        error
+      );
+    }
+  }
+
+  /**
+   * 自定义错误处理
+   */
+  async handleError(error: Error): Promise<void> {
+    await super.handleError(error);
+    this.setState('lastError', error.message);
+    this.setState('errorTimestamp', new Date().toISOString());
+  }
+
+  /**
+   * 获取帮助信息
+   */
+  getHelp(): string {
+    return `
+Tool: ${this.name} (v${this.version})
+Category: ${this.category}
+Description: ${this.description}
+
+Operations:
+- read: Read file content
+  Args: path (string)
+
+- write: Write content to file
+  Args: path (string), content (string)
+
+- delete: Delete a file
+  Args: path (string)
+
+- list: List directory contents
+  Args: path (string, optional)
+
+Examples:
+1. Read file:
+   { operation: 'read', path: '/path/to/file.txt' }
+
+2. Write file:
+   { operation: 'write', path: '/path/to/file.txt', content: 'Hello World' }
+
+3. Delete file:
+   { operation: 'delete', path: '/path/to/file.txt' }
+
+4. List directory:
+   { operation: 'list', path: '/path/to/dir' }
+    `.trim();
+  }
+} 

package/src/tools/tool-recommend.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 工具推荐器接口
+ */
+export interface ToolRecommender {
+  getRecommendedToolInfo(context: string, plan?: any): Promise<string>;
+}
+
+/**
+ * BM25 工具推荐器
+ */
+export declare class BM25ToolRecommender implements ToolRecommender {
+  constructor(tools: string[]);
+  getRecommendedToolInfo(context: string, plan?: any): Promise<string>;
+} 

package/src/tools/tool-recommend.ts

@@ -0,0 +1,31 @@
+import type { LLMProvider } from '../types/llm';
+
+/**
+ * 工具推荐器接口
+ */
+export interface ToolRecommender {
+  getRecommendedToolInfo(context: string, plan?: any): Promise<string>;
+}
+
+/**
+ * BM25 工具推荐器
+ */
+export class BM25ToolRecommender implements ToolRecommender {
+  private tools: string[];
+
+  constructor(tools: string[]) {
+    this.tools = tools;
+  }
+
+  /**
+   * 基于上下文和计划获取推荐工具信息
+   */
+  async getRecommendedToolInfo(context: string, plan?: any): Promise<string> {
+    if (!context || this.tools.length === 0) {
+      return '';
+    }
+
+    // Simple implementation returning all tools
+    return `Available tools: ${this.tools.join(', ')}`;
+  }
+} 

package/src/types/action.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { Message } from './message';
+
+export const ActionStatusSchema = z.enum([
+  'created',
+  'running',
+  'completed',
+  'failed',
+  'blocked'
+]);
+
+export type ActionStatus = z.infer<typeof ActionStatusSchema>;
+
+export const ActionOutputSchema = z.object({
+  content: z.string(),
+  status: ActionStatusSchema,
+  instructContent: z.any().optional(),
+});
+
+export type ActionOutput = z.infer<typeof ActionOutputSchema>;
+
+export const ActionContextSchema = z.object({
+  // TODO: Define action context properties
+  memory: z.any(),
+  workingMemory: z.any(),
+  llm: z.any(),
+});
+
+export type ActionContext = z.infer<typeof ActionContextSchema>;
+
+export interface Action {
+  name: string;
+  context: ActionContext;
+  llm: any; // TODO: Define LLMProvider type
+  
+  run(): Promise<ActionOutput>;
+  handleException(error: Error): Promise<void>;
+} 

package/src/types/config.ts

@@ -0,0 +1,129 @@
+/**
+ * @module Config
+ * @category Core
+ */
+
+import { z } from 'zod';
+import type { LLMConfig } from './llm';
+
+/**
+ * CLI parameters configuration schema
+ * Defines command line interface parameters for the application
+ */
+export const CLIParamsSchema = z.object({
+  /** Project directory path */
+  projectPath: z.string().default(''),
+  /** Project name */
+  projectName: z.string().default(''),
+  /** Whether to use incremental mode */
+  inc: z.boolean().default(false),
+  /** Path to requirements file */
+  reqaFile: z.string().default(''),
+  /** Maximum number of auto code summarizations */
+  maxAutoSummarizeCode: z.number().default(0),
+  /** Whether to reinitialize Git */
+  gitReinit: z.boolean().default(false),
+});
+
+export type CLIParams = z.infer<typeof CLIParamsSchema>;
+
+/**
+ * Embedding configuration schema
+ * Defines settings for text embedding operations
+ */
+export const EmbeddingConfigSchema = z.object({
+  /** API type (e.g., 'openai') */
+  apiType: z.string().default('openai'),
+  /** API key for authentication */
+  apiKey: z.string().optional(),
+  /** Model name for embeddings */
+  model: z.string().default('text-embedding-ada-002'),
+  /** Proxy URL if needed */
+  proxy: z.string().optional(),
+  /** Batch size for embedding operations */
+  batchSize: z.number().default(512),
+});
+
+export type EmbeddingConfig = z.infer<typeof EmbeddingConfigSchema>;
+
+/**
+ * Workspace configuration schema
+ * Defines settings for the application workspace
+ */
+export const WorkspaceConfigSchema = z.object({
+  /** Root directory for workspace */
+  root: z.string().default('./workspace'),
+  /** Whether to automatically clean workspace */
+  autoClean: z.boolean().default(false),
+  /** Path for storage */
+  storagePath: z.string().default('./storage'),
+});
+
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+
+/**
+ * Search configuration schema
+ * Defines settings for search operations
+ */
+export const SearchConfigSchema = z.object({
+  /** Search engine to use */
+  engine: z.string().default('google'),
+  /** API key for search engine */
+  apiKey: z.string().optional(),
+  /** Proxy URL if needed */
+  proxy: z.string().optional(),
+  /** Maximum results per search */
+  maxResults: z.number().default(10),
+});
+
+export type SearchConfig = z.infer<typeof SearchConfigSchema>;
+
+/**
+ * Main configuration schema
+ * Combines all configuration schemas into one comprehensive configuration
+ */
+export const ConfigSchema = CLIParamsSchema.extend({
+  /** LLM provider configuration */
+  llm: z.any(), // LLMConfig type
+  /** Embedding configuration */
+  embedding: EmbeddingConfigSchema.default({}),
+  /** Global proxy URL */
+  proxy: z.string().default(''),
+  /** Search configuration */
+  search: SearchConfigSchema.default({}),
+  /** Workspace configuration */
+  workspace: WorkspaceConfigSchema.default({}),
+  /** Whether to enable long-term memory */
+  enableLongtermMemory: z.boolean().default(false),
+  /** Number of code review iterations */
+  codeReviewKTimes: z.number().default(2),
+  /** Interface language */
+  language: z.string().default('English'),
+  /** Additional configuration options */
+  extra: z.record(z.any()).default({}),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+/**
+ * Configuration source type
+ * Defines possible sources for configuration values
+ */
+export type ConfigSource = 'env' | 'file' | 'default' | 'cli';
+
+/**
+ * Configuration loading options schema
+ * Defines options for loading configuration
+ */
+export const ConfigOptionsSchema = z.object({
+  /** Path to configuration file */
+  configPath: z.string().optional(),
+  /** Whether to load from environment variables */
+  loadEnv: z.boolean().default(true),
+  /** Whether to use default values */
+  useDefaults: z.boolean().default(true),
+  /** Priority order for configuration sources */
+  sourcePriority: z.array(z.enum(['env', 'file', 'default', 'cli'])).default(['cli', 'env', 'file', 'default']),
+});
+
+export type ConfigOptions = z.infer<typeof ConfigOptionsSchema>;