@louloulinx/metagpt 0.1.3

package/src/config/browser.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+/**
+ * Browser type enumeration
+ */
+export enum BrowserType {
+  PLAYWRIGHT = 'playwright',
+  PUPPETEER = 'puppeteer',
+  SELENIUM = 'selenium',
+}
+
+/**
+ * Browser configuration schema
+ */
+export const BrowserConfigSchema = z.object({
+  browserType: z.nativeEnum(BrowserType).default(BrowserType.PLAYWRIGHT),
+  headless: z.boolean().default(true),
+  timeout: z.number().default(30000),
+  waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle', 'commit']).default('networkidle'),
+  proxy: z.string().optional(),
+  userAgent: z.string().optional(),
+  viewport: z.object({
+    width: z.number().default(1280),
+    height: z.number().default(800),
+  }).optional(),
+  ignoreHTTPSErrors: z.boolean().default(true),
+  maxConcurrency: z.number().default(10),
+  retryCount: z.number().default(3),
+  downloadPath: z.string().optional(),
+  extraHeaders: z.record(z.string()).default({}),
+});
+
+export type BrowserConfig = z.infer<typeof BrowserConfigSchema>; 

package/src/config/config.ts

@@ -0,0 +1,345 @@
+/**
+ * @module Config
+ * @category Core
+ */
+
+import { z } from 'zod';
+import path from 'path';
+import fs from 'fs/promises';
+import { readFileSync } from 'fs';
+import { merge } from 'lodash';
+import { LLMType, LLMConfigSchema } from './llm';
+import type { LLMConfig } from './llm';
+import type { EmbeddingConfig } from './embedding';
+import { EmbeddingConfigSchema } from './embedding';
+import type { OmniParseConfig } from './omniparse';
+import { OmniParseConfigSchema } from './omniparse';
+import type { SearchConfig } from './search';
+import { SearchConfigSchema } from './search';
+import type { BrowserConfig } from './browser';
+import { BrowserConfigSchema } from './browser';
+import type { MermaidConfig } from './mermaid';
+import { MermaidConfigSchema } from './mermaid';
+import type { S3Config } from './s3';
+import { S3ConfigSchema } from './s3';
+import type { RedisConfig } from './redis';
+import { RedisConfigSchema } from './redis';
+import type { WorkspaceConfig } from './workspace';
+import { WorkspaceConfigSchema } from './workspace';
+import { YamlModel } from '../utils/yaml';
+
+/**
+ * CLI parameters schema
+ */
+export const CLIParamsSchema = z.object({
+  projectPath: z.string().default(''),
+  projectName: z.string().default(''),
+  inc: z.boolean().default(false),
+  reqaFile: z.string().default(''),
+  maxAutoSummarizeCode: z.number().default(0),
+  gitReinit: z.boolean().default(false),
+}).transform((data) => {
+  if (data.projectPath) {
+    data.inc = true;
+    data.projectName = data.projectName || path.basename(data.projectPath);
+  }
+  return data;
+});
+
+/**
+ * Main configuration schema for MetaGPT
+ */
+export const ConfigSchema = z.object({
+  // CLI Parameters
+  projectPath: z.string().default(''),
+  projectName: z.string().default(''),
+  inc: z.boolean().default(false),
+  reqaFile: z.string().default(''),
+  maxAutoSummarizeCode: z.number().default(0),
+  gitReinit: z.boolean().default(false),
+
+  // Key Parameters
+  llm: LLMConfigSchema.default({
+    apiType: LLMType.OPENAI,
+    apiKey: '',
+    model: 'gpt-4',
+    maxTokens: 4096,
+    temperature: 0.7,
+    topP: 1,
+    n: 1,
+    presencePenalty: 0,
+    frequencyPenalty: 0,
+    maxRetries: 3,
+    timeout: 60000,
+  }),
+
+  // RAG Embedding
+  embedding: EmbeddingConfigSchema.default({}),
+
+  // Omniparse
+  omniparse: OmniParseConfigSchema.default({}),
+
+  // Global Proxy
+  proxy: z.string().default(''),
+
+  // Tool Parameters
+  search: SearchConfigSchema.default({}),
+  browser: BrowserConfigSchema.default({}),
+  mermaid: MermaidConfigSchema.default({}),
+
+  // Storage Parameters
+  s3: S3ConfigSchema.optional(),
+  redis: RedisConfigSchema.optional(),
+
+  // Misc Parameters
+  repairLlmOutput: z.boolean().default(false),
+  promptSchema: z.enum(['json', 'markdown', 'raw']).default('json'),
+  workspace: WorkspaceConfigSchema.default({}),
+  enableLongtermMemory: z.boolean().default(false),
+  codeReviewKTimes: z.number().default(2),
+  agentopsApiKey: z.string().default(''),
+
+  // Legacy Parameters (to be removed)
+  metagptTtiUrl: z.string().default(''),
+  language: z.string().default('English'),
+  redisKey: z.string().default('placeholder'),
+  iflytekAppId: z.string().default(''),
+  iflytekApiSecret: z.string().default(''),
+  iflytekApiKey: z.string().default(''),
+  azureTtsSubscriptionKey: z.string().default(''),
+  azureTtsRegion: z.string().default(''),
+  extra: z.record(z.any()).default({}),
+});
+
+export type Config = z.infer<typeof ConfigSchema>;
+
+/**
+ * Configuration manager class for MetaGPT
+ */
+export class ConfigManager {
+  private config: Config;
+  private static instance: ConfigManager;
+
+  private constructor(config: Config) {
+    this.config = config;
+  }
+
+  /**
+   * Get singleton instance of ConfigManager
+   */
+  public static getInstance(options: { configPath?: string; loadEnv?: boolean; useDefaults?: boolean } = {}): ConfigManager {
+    if (!ConfigManager.instance) {
+      const config = ConfigSchema.parse({});
+      ConfigManager.instance = new ConfigManager(config);
+      
+      if (options.loadEnv) {
+        ConfigManager.instance.updateConfig(process.env as Partial<Config>);
+      }
+      
+      if (options.configPath) {
+        try {
+          const content = readFileSync(options.configPath, 'utf-8');
+          const fileConfig = YamlModel.parse(content) as Partial<Config>;
+          ConfigManager.instance.updateConfig(fileConfig);
+        } catch (e) {
+          // Ignore file read errors
+        }
+      }
+    }
+    return ConfigManager.instance;
+  }
+
+  /**
+   * Get current configuration
+   */
+  public getConfig(): Config {
+    return this.config;
+  }
+
+  /**
+   * Update configuration
+   */
+  public updateConfig(config: Partial<Config>): void {
+    this.config = ConfigSchema.parse({
+      ...this.config,
+      ...config,
+    });
+  }
+
+  /**
+   * Load configuration from home directory
+   */
+  public static async fromHome(configPath: string): Promise<ConfigManager | null> {
+    const homePath = process.env.HOME || process.env.USERPROFILE;
+    if (!homePath) return null;
+
+    const configFile = path.join(homePath, '.metagpt', configPath);
+    try {
+      const content = await fs.readFile(configFile, 'utf-8');
+      const config = YamlModel.parse(content);
+      return new ConfigManager(ConfigSchema.parse(config));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Load default configuration
+   */
+  public static async default(): Promise<ConfigManager> {
+    const defaultPaths = [
+      path.join(process.cwd(), 'config/config.yaml'),
+      path.join(process.env.HOME || '', '.metagpt/config.yaml'),
+    ];
+
+    const configs = [process.env];
+    for (const configPath of defaultPaths) {
+      try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        configs.push(YamlModel.parse(content));
+      } catch {
+        continue;
+      }
+    }
+
+    const mergedConfig = merge({}, ...configs);
+    return new ConfigManager(ConfigSchema.parse(mergedConfig));
+  }
+
+  /**
+   * Create configuration from LLM config
+   */
+  public static fromLLMConfig(llmConfig: Partial<LLMConfig>): ConfigManager {
+    const config = merge({}, process.env, { llm: llmConfig });
+    return new ConfigManager(ConfigSchema.parse(config));
+  }
+
+  /**
+   * Create configuration from environment variables
+   */
+  public static fromEnvironment(): ConfigManager {
+    const envConfig: Partial<Config> = {};
+    
+    // Parse OpenAI configuration from environment
+    if (process.env.OPENAI_API_KEY) {
+      envConfig.llm = {
+        apiType: LLMType.OPENAI,
+        apiKey: process.env.OPENAI_API_KEY || '',
+        model: process.env.OPENAI_MODEL || 'gpt-4',
+        maxTokens: 4096,
+        temperature: 0.7,
+        topP: 1,
+        n: 1,
+        presencePenalty: 0,
+        frequencyPenalty: 0,
+        maxRetries: 3,
+        timeout: 60000,
+      };
+    }
+    
+    // Parse Azure configuration from environment
+    if (process.env.AZURE_API_KEY) {
+      envConfig.llm = {
+        apiType: LLMType.AZURE,
+        apiKey: process.env.AZURE_API_KEY || '',
+        model: process.env.AZURE_MODEL || 'gpt-4',
+        maxTokens: 4096,
+        temperature: 0.7,
+        topP: 1,
+        n: 1,
+        presencePenalty: 0,
+        frequencyPenalty: 0,
+        maxRetries: 3,
+        timeout: 60000,
+        endpoint: process.env.AZURE_ENDPOINT,
+        apiVersion: process.env.AZURE_API_VERSION,
+        deploymentName: process.env.AZURE_DEPLOYMENT_NAME,
+      };
+    }
+    
+    // Parse proxy configuration
+    if (process.env.METAGPT_PROXY) {
+      envConfig.proxy = process.env.METAGPT_PROXY;
+    }
+    
+    // Parse other common environment variables
+    if (process.env.METAGPT_PROJECT_PATH) {
+      envConfig.projectPath = process.env.METAGPT_PROJECT_PATH;
+    }
+    
+    if (process.env.METAGPT_PROJECT_NAME) {
+      envConfig.projectName = process.env.METAGPT_PROJECT_NAME;
+    }
+    
+    return new ConfigManager(ConfigSchema.parse(envConfig));
+  }
+
+  /**
+   * Merge configurations according to priority
+   */
+  public static async mergeConfigs(fileConfig: ConfigManager, cliConfig: Partial<Config>): Promise<ConfigManager> {
+    // Priority: CLI > File config > Environment variables
+    const envConfig = ConfigManager.fromEnvironment();
+    
+    // Merge in order of priority
+    const mergedConfig = merge(
+      {}, 
+      envConfig.getConfig(), 
+      fileConfig.getConfig(), 
+      cliConfig as Record<string, unknown>
+    );
+    
+    return new ConfigManager(ConfigSchema.parse(mergedConfig));
+  }
+
+  /**
+   * Update configuration via CLI parameters
+   */
+  public updateViaCLI(params: Partial<z.infer<typeof CLIParamsSchema>>): void {
+    const { projectPath, projectName, inc, reqaFile, maxAutoSummarizeCode } = params;
+    
+    this.config = ConfigSchema.parse({
+      ...this.config,
+      projectPath,
+      projectName: projectName || (projectPath ? path.basename(projectPath) : ''),
+      inc: inc || !!projectPath,
+      reqaFile,
+      maxAutoSummarizeCode,
+    });
+  }
+
+  /**
+   * Get OpenAI LLM configuration
+   */
+  public getOpenAILLM(): LLMConfig | null {
+    return this.config.llm.apiType === LLMType.OPENAI ? this.config.llm as LLMConfig : null;
+  }
+
+  /**
+   * Get Azure LLM configuration
+   */
+  public getAzureLLM(): LLMConfig | null {
+    return this.config.llm.apiType === LLMType.AZURE ? this.config.llm as LLMConfig : null;
+  }
+
+  /**
+   * Get extra configuration
+   */
+  public get extra(): Record<string, any> {
+    return this.config.extra as Record<string, any>;
+  }
+
+  /**
+   * Set extra configuration
+   */
+  public set extra(value: Record<string, any>) {
+    this.config.extra = value;
+  }
+}
+
+/**
+ * Get default configuration instance
+ */
+export async function getConfig(): Promise<ConfigManager> {
+  return ConfigManager.default();
+} 

package/src/config/embedding.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+/**
+ * Embedding model types
+ */
+export enum EmbeddingModelType {
+  OPENAI = 'text-embedding-ada-002',
+  HUGGINGFACE = 'sentence-transformers/all-mpnet-base-v2',
+  CUSTOM = 'custom',
+}
+
+/**
+ * Embedding configuration schema
+ */
+export const EmbeddingConfigSchema = z.object({
+  modelType: z.nativeEnum(EmbeddingModelType).default(EmbeddingModelType.OPENAI),
+  modelName: z.string().optional(),
+  dimensions: z.number().default(1536),
+  apiKey: z.string().optional(),
+  apiBase: z.string().optional(),
+  batchSize: z.number().default(512),
+  timeout: z.number().default(60),
+  maxRetries: z.number().default(3),
+});
+
+export type EmbeddingConfig = z.infer<typeof EmbeddingConfigSchema>; 

package/src/config/llm.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+
+/**
+ * LLM API types
+ */
+export enum LLMType {
+  OPENAI = 'openai',
+  AZURE = 'azure',
+  ANTHROPIC = 'anthropic',
+  HUGGINGFACE = 'huggingface',
+  CUSTOM = 'custom',
+}
+
+/**
+ * LLM configuration schema
+ */
+export const LLMConfigSchema = z.object({
+  apiType: z.nativeEnum(LLMType).default(LLMType.OPENAI),
+  apiKey: z.string().default(''),
+  apiBase: z.string().optional(),
+  apiVersion: z.string().optional(),
+  model: z.string().default('gpt-4'),
+  maxTokens: z.number().default(2000),
+  temperature: z.number().default(0.7),
+  topP: z.number().default(0.95),
+  n: z.number().default(1),
+  stop: z.array(z.string()).optional(),
+  presencePenalty: z.number().default(0.0),
+  frequencyPenalty: z.number().default(0.0),
+  logitBias: z.record(z.number()).optional(),
+  proxy: z.string().optional(),
+  timeout: z.number().default(60),
+  maxRetries: z.number().default(3),
+});
+
+export type LLMConfig = z.infer<typeof LLMConfigSchema>; 

package/src/config/mermaid.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+
+/**
+ * Mermaid theme types
+ */
+export enum MermaidTheme {
+  DEFAULT = 'default',
+  FOREST = 'forest',
+  DARK = 'dark',
+  NEUTRAL = 'neutral',
+}
+
+/**
+ * Mermaid configuration schema
+ */
+export const MermaidConfigSchema = z.object({
+  theme: z.nativeEnum(MermaidTheme).default(MermaidTheme.DEFAULT),
+  startOnLoad: z.boolean().default(true),
+  securityLevel: z.enum(['strict', 'loose', 'antiscript']).default('strict'),
+  logLevel: z.enum(['debug', 'info', 'warn', 'error', 'fatal']).default('info'),
+  arrowMarkerAbsolute: z.boolean().default(false),
+  flowchart: z.object({
+    htmlLabels: z.boolean().default(true),
+    curve: z.enum(['basis', 'linear', 'cardinal']).default('linear'),
+  }).default({}),
+  sequence: z.object({
+    diagramMarginX: z.number().default(50),
+    diagramMarginY: z.number().default(10),
+    actorMargin: z.number().default(50),
+    width: z.number().default(150),
+    height: z.number().default(65),
+  }).default({}),
+  fontSize: z.number().default(16),
+  fontFamily: z.string().default('trebuchet ms'),
+});
+
+export type MermaidConfig = z.infer<typeof MermaidConfigSchema>; 

package/src/config/omniparse.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+/**
+ * Omniparse configuration schema for file parsing settings
+ */
+export const OmniParseConfigSchema = z.object({
+  maxFileSize: z.number().default(10 * 1024 * 1024), // 10MB
+  supportedFormats: z.array(z.string()).default([
+    '.txt', '.md', '.pdf', '.doc', '.docx',
+    '.xls', '.xlsx', '.csv', '.json', '.xml',
+    '.html', '.htm', '.py', '.js', '.ts',
+    '.jsx', '.tsx', '.java', '.cpp', '.c',
+    '.h', '.cs', '.go', '.rs', '.php',
+    '.rb', '.swift', '.kt', '.scala', '.sql',
+  ]),
+  extractImages: z.boolean().default(false),
+  extractTables: z.boolean().default(true),
+  preserveFormatting: z.boolean().default(true),
+  chunkSize: z.number().default(1000),
+  overlapSize: z.number().default(100),
+  timeout: z.number().default(30),
+  maxRetries: z.number().default(3),
+});
+
+export type OmniParseConfig = z.infer<typeof OmniParseConfigSchema>; 

package/src/config/redis.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+
+/**
+ * Redis configuration schema
+ */
+export const RedisConfigSchema = z.object({
+  host: z.string().default('localhost'),
+  port: z.number().default(6379),
+  db: z.number().default(0),
+  password: z.string().optional(),
+  username: z.string().optional(),
+  tls: z.boolean().default(false),
+  sentinel: z.object({
+    enabled: z.boolean().default(false),
+    masterName: z.string().optional(),
+    nodes: z.array(z.object({
+      host: z.string(),
+      port: z.number(),
+    })).optional(),
+  }).default({}),
+  cluster: z.object({
+    enabled: z.boolean().default(false),
+    nodes: z.array(z.object({
+      host: z.string(),
+      port: z.number(),
+    })).optional(),
+  }).default({}),
+  maxRetries: z.number().default(3),
+  retryDelay: z.number().default(1000),
+  connectTimeout: z.number().default(10000),
+  keyPrefix: z.string().default('metagpt:'),
+});
+
+export type RedisConfig = z.infer<typeof RedisConfigSchema>; 

package/src/config/s3.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+/**
+ * S3 provider types
+ */
+export enum S3ProviderType {
+  AWS = 'aws',
+  MINIO = 'minio',
+  CUSTOM = 'custom',
+}
+
+/**
+ * S3 configuration schema
+ */
+export const S3ConfigSchema = z.object({
+  provider: z.nativeEnum(S3ProviderType).default(S3ProviderType.AWS),
+  accessKeyId: z.string(),
+  secretAccessKey: z.string(),
+  region: z.string().default('us-east-1'),
+  bucket: z.string(),
+  endpoint: z.string().optional(),
+  forcePathStyle: z.boolean().default(false),
+  sslEnabled: z.boolean().default(true),
+  maxRetries: z.number().default(3),
+  timeout: z.number().default(60),
+  uploadOptions: z.object({
+    partSize: z.number().default(5 * 1024 * 1024), // 5MB
+    queueSize: z.number().default(4),
+  }).default({}),
+  presignedUrlExpiry: z.number().default(3600), // 1 hour
+});
+
+export type S3Config = z.infer<typeof S3ConfigSchema>; 

package/src/config/search.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+/**
+ * Search provider types
+ */
+export enum SearchProviderType {
+  SERPAPI = 'serpapi',
+  GOOGLE = 'google',
+  BING = 'bing',
+  CUSTOM = 'custom',
+}
+
+/**
+ * Search configuration schema
+ */
+export const SearchConfigSchema = z.object({
+  provider: z.nativeEnum(SearchProviderType).default(SearchProviderType.SERPAPI),
+  apiKey: z.string().default(''),
+  customSearchId: z.string().optional(),
+  maxResults: z.number().default(10),
+  timeout: z.number().default(30),
+  maxRetries: z.number().default(3),
+  proxy: z.string().optional(),
+  safeSearch: z.boolean().default(true),
+  language: z.string().default('en'),
+  region: z.string().default('us'),
+  includeParams: z.record(z.any()).default({}),
+});
+
+export type SearchConfig = z.infer<typeof SearchConfigSchema>; 

package/src/config/workspace.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Config
+ * @category Core
+ */
+
+import { z } from 'zod';
+
+/**
+ * Workspace configuration schema
+ */
+export const WorkspaceConfigSchema = z.object({
+  root: z.string().default('./workspace'),
+  autoClean: z.boolean().default(false),
+  storagePath: z.string().default('./storage'),
+});
+
+/**
+ * Workspace configuration type
+ */
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>; 

package/src/index.ts

@@ -0,0 +1,40 @@
+// 基础类型定义
+export * from './types/message';
+export * from './types/role';
+export * from './types/action';
+export * from './types/memory';
+export * from './types/llm';
+export * from './types/skill';
+export * from './types/tool';
+export * from './types/rag';
+
+// 角色实现
+export * from './roles/base-role';
+export * from './roles/engineer';
+export * from './roles/tutorial-assistant';
+
+// 动作实现
+export * from './actions/base-action';
+export * from './actions/analyze-task';
+export * from './actions/write-tutorial';
+
+// 技能实现
+export * from './skills/base-skill';
+export * from './skills/code-review';
+
+// 工具实现
+export * from './tools/base-tool';
+export * from './tools/file-system';
+
+// RAG 实现
+export * from './rag/base-rag';
+export * from './rag/document-qa';
+
+// 提供商实现
+export * from './provider/vercel-llm';
+
+// 工具函数
+export * from './utils/common';
+
+// 版本信息
+export const VERSION = '0.1.0';