@louloulinx/metagpt 0.1.3

package/src/types/rag.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import type { LLMProvider } from './llm';
+
+/**
+ * 向量存储配置
+ */
+export const VectorStoreConfigSchema = z.object({
+  /** 服务器URL */
+  url: z.string(),
+  /** 集合名称 */
+  collectionName: z.string(),
+  /** 向量维度 */
+  dimension: z.number(),
+  /** 距离度量方式 */
+  distance: z.enum(['Cosine', 'Euclidean', 'Dot']),
+  /** API密钥 */
+  apiKey: z.string().optional(),
+});
+
+export type VectorStoreConfig = z.infer<typeof VectorStoreConfigSchema>;
+
+/**
+ * RAG系统配置
+ */
+export const RAGConfigSchema = z.object({
+  /** LLM提供商 */
+  llm: z.any(), // LLMProvider
+  /** 向量存储配置 */
+  vectorStore: VectorStoreConfigSchema,
+  /** 分块大小 */
+  chunkSize: z.number().default(1000),
+  /** 分块重叠大小 */
+  chunkOverlap: z.number().default(200),
+  /** 检索结果数量 */
+  topK: z.number().default(5),
+  /** 最小相似度分数 */
+  minScore: z.number().default(0.7),
+});
+
+export type RAGConfig = z.infer<typeof RAGConfigSchema>;
+
+/**
+ * 文档块结构
+ */
+export const ChunkSchema = z.object({
+  /** 块ID */
+  id: z.string(),
+  /** 块内容 */
+  content: z.string(),
+  /** 块向量 */
+  embedding: z.array(z.number()),
+  /** 块元数据 */
+  metadata: z.record(z.any()),
+});
+
+export type Chunk = z.infer<typeof ChunkSchema>;
+
+/**
+ * 搜索结果结构
+ */
+export const SearchResultSchema = z.object({
+  /** 匹配的文档块 */
+  chunk: ChunkSchema,
+  /** 相似度分数 */
+  score: z.number(),
+  /** 结果元数据 */
+  metadata: z.record(z.any()),
+});
+
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+
+/**
+ * RAG系统接口
+ */
+export interface RAGSystem {
+  /** 添加文档 */
+  addDocument(content: string, metadata?: Record<string, any>): Promise<Chunk[]>;
+  /** 删除文档块 */
+  deleteChunks(ids: string[]): Promise<void>;
+  /** 更新文档块 */
+  updateChunk(chunk: Chunk): Promise<void>;
+  /** 搜索相关文档 */
+  search(query: string, topK?: number): Promise<SearchResult[]>;
+  /** 生成回答 */
+  generate(query: string): Promise<string>;
+} 

package/src/types/role.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import type { Message } from './message';
+import type { Action } from './action';
+import { createMachine } from 'xstate';
+
+export const RoleContextSchema = z.object({
+  memory: z.any(), // TODO: Define Memory type
+  workingMemory: z.any(), // TODO: Define Memory type
+  state: z.number(),
+  todo: z.any().nullable(), // TODO: Define Action type
+  watch: z.set(z.string()),
+  reactMode: z.enum(['react', 'by_order', 'plan_and_act']),
+});
+
+export type RoleContext = z.infer<typeof RoleContextSchema>;
+
+export const RoleSchema = z.object({
+  name: z.string(),
+  profile: z.string(),
+  goal: z.string(),
+  constraints: z.string(),
+  actions: z.array(z.any()), // TODO: Define Action type
+});
+
+export type Role = z.infer<typeof RoleSchema> & {
+  observe(): Promise<number>;
+  think(): Promise<boolean>;
+  act(): Promise<Message>;
+  react(): Promise<Message>;
+  state: number;
+  context: RoleContext;
+};
+
+// 角色状态机定义
+export const roleStateMachine = createMachine({
+  id: 'role',
+  initial: 'idle',
+  states: {
+    idle: {
+      on: { OBSERVE: 'observing' }
+    },
+    observing: {
+      on: { 
+        THINK: 'thinking',
+        COMPLETE: 'idle'
+      }
+    },
+    thinking: {
+      on: { 
+        ACT: 'acting',
+        COMPLETE: 'idle'
+      }
+    },
+    acting: {
+      on: { 
+        REACT: 'reacting',
+        COMPLETE: 'idle'
+      }
+    },
+    reacting: {
+      on: { 
+        OBSERVE: 'observing',
+        COMPLETE: 'idle'
+      }
+    }
+  }
+}); 

package/src/types/skill.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import type { Action } from './action';
+import type { LLMProvider } from './llm';
+
+/**
+ * 技能配置结构
+ */
+export const SkillConfigSchema = z.object({
+  name: z.string(),                      // 技能名称
+  description: z.string(),               // 技能描述
+  llm: z.any(),                         // LLM 提供商
+  actions: z.array(z.any()).optional(), // 技能包含的动作
+  args: z.record(z.any()).optional(),   // 技能参数
+});
+
+export type SkillConfig = z.infer<typeof SkillConfigSchema>;
+
+/**
+ * 技能上下文结构
+ */
+export const SkillContextSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  actions: z.array(z.any()),
+  args: z.record(z.any()).optional(),
+  llm: z.any(),
+});
+
+export type SkillContext = z.infer<typeof SkillContextSchema>;
+
+/**
+ * 技能执行结果结构
+ */
+export const SkillResultSchema = z.object({
+  success: z.boolean(),                 // 执行是否成功
+  message: z.string(),                  // 结果消息
+  data: z.any().optional(),            // 执行结果数据
+  error: z.any().optional(),           // 错误信息
+});
+
+export type SkillResult = z.infer<typeof SkillResultSchema>;
+
+/**
+ * 技能接口
+ */
+export interface Skill {
+  name: string;                        // 技能名称
+  description: string;                 // 技能描述
+  context: SkillContext;              // 技能上下文
+  llm: LLMProvider;                   // LLM 提供商
+  actions: Action[];                  // 技能包含的动作
+
+  /**
+   * 执行技能
+   * @param args 执行参数
+   * @returns 执行结果
+   */
+  execute(args?: Record<string, any>): Promise<SkillResult>;
+
+  /**
+   * 验证技能是否可用
+   * @returns 验证结果
+   */
+  validate(): Promise<boolean>;
+
+  /**
+   * 处理技能执行异常
+   * @param error 错误对象
+   */
+  handleError(error: Error): Promise<void>;
+} 

package/src/types/task.ts

@@ -0,0 +1,32 @@
+/**
+ * 任务类型枚举
+ */
+export enum TaskType {
+  DATA_ANALYSIS = 'DATA_ANALYSIS',
+  DATA_PREPROCESS = 'DATA_PREPROCESS',
+  FEATURE_ENGINEERING = 'FEATURE_ENGINEERING',
+  MODEL_TRAIN = 'MODEL_TRAIN',
+  MODEL_EVALUATION = 'MODEL_EVALUATION',
+  VISUALIZATION = 'VISUALIZATION',
+  RECOMMENDATION = 'RECOMMENDATION',
+}
+
+/**
+ * 任务接口
+ */
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  task_type: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+
+/**
+ * 任务结果接口
+ */
+export interface TaskResult {
+  code: string;
+  result: string;
+  isSuccess: boolean;
+} 

package/src/types/team.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Role } from './role';
+import { Environment } from '../environment/environment';
+import { Context } from '../context/context';
+import { Message } from './message';
+
+/**
+ * Team configuration schema
+ */
+export const TeamConfigSchema = z.object({
+  /** Environment for team communication and state management */
+  environment: z.instanceof(Environment).optional(),
+  /** Initial investment amount */
+  investment: z.number().default(10.0),
+  /** Project idea or requirement */
+  idea: z.string().default(''),
+  /** Team context */
+  context: z.instanceof(Context).optional(),
+  /** Team roles */
+  roles: z.array(z.instanceof(Role)).optional(),
+  /** Environment description */
+  envDesc: z.string().optional(),
+});
+
+export type TeamConfig = z.infer<typeof TeamConfigSchema>;
+
+/**
+ * Team state schema
+ */
+export const TeamStateSchema = z.object({
+  /** Current round number */
+  currentRound: z.number().default(0),
+  /** Whether team is running */
+  isRunning: z.boolean().default(false),
+  /** Whether team is archived */
+  isArchived: z.boolean().default(false),
+  /** Team history */
+  history: z.array(z.instanceof(Message)).default([]),
+});
+
+export type TeamState = z.infer<typeof TeamStateSchema>;
+
+/**
+ * Team storage schema for serialization
+ */
+export const TeamStorageSchema = z.object({
+  /** Team configuration */
+  config: TeamConfigSchema,
+  /** Team state */
+  state: TeamStateSchema,
+  /** Storage path */
+  storagePath: z.string().optional(),
+});
+
+export type TeamStorage = z.infer<typeof TeamStorageSchema>; 

package/src/types/tool.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+
+/**
+ * 工具配置结构
+ */
+export const ToolConfigSchema = 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(), // 元数据
+});
+
+export type ToolConfig = z.infer<typeof ToolConfigSchema>;
+
+/**
+ * 工具上下文结构
+ */
+export const ToolContextSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  args: z.record(z.any()).optional(),
+  metadata: z.record(z.any()).optional(),
+  state: z.record(z.any()).optional(),
+});
+
+export type ToolContext = z.infer<typeof ToolContextSchema>;
+
+/**
+ * 工具执行结果结构
+ */
+export const ToolResultSchema = z.object({
+  success: z.boolean(),                // 执行是否成功
+  message: z.string(),                 // 结果消息
+  data: z.any().optional(),           // 执行结果数据
+  error: z.any().optional(),          // 错误信息
+  metadata: z.record(z.any()).optional(), // 结果元数据
+});
+
+export type ToolResult = z.infer<typeof ToolResultSchema>;
+
+/**
+ * 工具接口
+ */
+export interface Tool {
+  name: string;                       // 工具名称
+  description: string;                // 工具描述
+  version: string;                    // 工具版本
+  category: string;                   // 工具类别
+  context: ToolContext;              // 工具上下文
+
+  /**
+   * 执行工具
+   * @param args 执行参数
+   * @returns 执行结果
+   */
+  execute(args?: Record<string, any>): Promise<ToolResult>;
+
+  /**
+   * 验证工具是否可用
+   * @returns 验证结果
+   */
+  validate(): Promise<boolean>;
+
+  /**
+   * 处理工具执行异常
+   * @param error 错误对象
+   */
+  handleError(error: Error): Promise<void>;
+
+  /**
+   * 获取工具帮助信息
+   * @returns 帮助信息
+   */
+  getHelp(): string;
+} 

package/src/types/workflow.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import type { Role } from './role';
+import type { Action } from './action';
+import type { Message } from './message';
+
+/**
+ * 工作流节点类型
+ */
+export const WorkflowNodeSchema = z.object({
+  /** 节点ID */
+  id: z.string(),
+  /** 节点名称 */
+  name: z.string(),
+  /** 节点类型 */
+  type: z.enum(['action', 'role', 'condition', 'parallel', 'sequence']),
+  /** 节点配置 */
+  config: z.record(z.any()).optional(),
+  /** 节点状态 */
+  status: z.enum(['pending', 'running', 'completed', 'failed']).default('pending'),
+  /** 节点执行结果 */
+  result: z.any().optional(),
+  /** 父节点ID */
+  parentId: z.string().optional(),
+  /** 子节点ID列表 */
+  childIds: z.array(z.string()).default([]),
+});
+
+export type WorkflowNode = z.infer<typeof WorkflowNodeSchema>;
+
+/**
+ * 工作流配置
+ */
+export const WorkflowConfigSchema = z.object({
+  /** 工作流ID */
+  id: z.string(),
+  /** 工作流名称 */
+  name: z.string(),
+  /** 工作流描述 */
+  description: z.string().optional(),
+  /** 工作流版本 */
+  version: z.string().default('1.0.0'),
+  /** 工作流节点列表 */
+  nodes: z.array(WorkflowNodeSchema),
+  /** 工作流配置 */
+  config: z.record(z.any()).optional(),
+  /** 工作流元数据 */
+  metadata: z.record(z.any()).optional(),
+});
+
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
+
+/**
+ * 工作流状态
+ */
+export const WorkflowStateSchema = z.object({
+  /** 工作流ID */
+  id: z.string(),
+  /** 工作流状态 */
+  status: z.enum(['pending', 'running', 'completed', 'failed']).default('pending'),
+  /** 当前执行的节点ID */
+  currentNodeId: z.string().optional(),
+  /** 已完成的节点ID列表 */
+  completedNodeIds: z.array(z.string()).default([]),
+  /** 失败的节点ID列表 */
+  failedNodeIds: z.array(z.string()).default([]),
+  /** 工作流执行历史 */
+  history: z.array(z.object({
+    timestamp: z.number(),
+    nodeId: z.string(),
+    status: z.string(),
+    message: z.string().optional(),
+  })).default([]),
+});
+
+export type WorkflowState = z.infer<typeof WorkflowStateSchema>;
+
+/**
+ * 工作流执行器接口
+ */
+export interface WorkflowExecutor {
+  /** 执行工作流 */
+  execute(config: WorkflowConfig): Promise<void>;
+  /** 暂停工作流 */
+  pause(): Promise<void>;
+  /** 恢复工作流 */
+  resume(): Promise<void>;
+  /** 停止工作流 */
+  stop(): Promise<void>;
+  /** 获取工作流状态 */
+  getState(): WorkflowState;
+}
+
+/**
+ * 工作流节点执行器接口
+ */
+export interface NodeExecutor {
+  /** 执行节点 */
+  execute(node: WorkflowNode, context: any): Promise<any>;
+  /** 验证节点配置 */
+  validate(node: WorkflowNode): boolean;
+  /** 获取节点状态 */
+  getStatus(): string;
+  /** 获取节点结果 */
+  getResult(): any;
+}
+
+/**
+ * 工作流事件类型
+ */
+export const WorkflowEventSchema = z.object({
+  /** 事件类型 */
+  type: z.enum([
+    'workflow:start',
+    'workflow:complete',
+    'workflow:fail',
+    'node:start',
+    'node:complete',
+    'node:fail',
+    'error'
+  ]),
+  /** 事件时间戳 */
+  timestamp: z.number(),
+  /** 工作流ID */
+  workflowId: z.string(),
+  /** 节点ID */
+  nodeId: z.string().optional(),
+  /** 事件数据 */
+  data: z.any().optional(),
+  /** 错误信息 */
+  error: z.any().optional(),
+});
+
+export type WorkflowEvent = z.infer<typeof WorkflowEventSchema>; 

package/src/utils/common.ts

@@ -0,0 +1,73 @@
+/**
+ * 将任意值转换为字符串
+ * @param value 要转换的值
+ * @returns 字符串表示
+ */
+export function anyToString(value: any): string {
+  if (typeof value === 'string') return value;
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  if (typeof value === 'function') return 'function: ' + (value.name || '(anonymous)');
+  if (typeof value === 'object') {
+    if (value instanceof Date) return 'Date: ' + value.toString();
+    try {
+      return value.toString() || JSON.stringify(value);
+    } catch (e) {
+      return Object.prototype.toString.call(value);
+    }
+  }
+  return String(value);
+}
+
+/**
+ * 将任意值转换为字符串集合
+ * @param value 要转换的值
+ * @returns 字符串集合
+ */
+export function anyToStringSet(value: any): Set<string> {
+  if (value instanceof Set) {
+    return new Set([...value].map(anyToString));
+  }
+  if (Array.isArray(value)) {
+    return new Set(value.map(anyToString));
+  }
+  return new Set([anyToString(value)]);
+}
+
+/**
+ * 生成唯一ID
+ * @returns UUID字符串
+ */
+export function generateId(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * 延迟执行
+ * @param ms 延迟毫秒数
+ * @returns Promise
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * 重试函数执行
+ * @param fn 要执行的函数
+ * @param retries 重试次数
+ * @param delay 重试延迟(ms)
+ * @returns Promise
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  retries: number = 3,
+  delayMs: number = 1000
+): Promise<T> {
+  try {
+    return await fn();
+  } catch (error) {
+    if (retries <= 0) throw error;
+    await delay(delayMs);
+    return retry(fn, retries - 1, delayMs);
+  }
+} 

package/src/utils/yaml.ts

@@ -0,0 +1,67 @@
+import * as yaml from 'js-yaml';
+import * as fs from 'fs/promises';
+import { stringify } from 'yaml';
+
+/**
+ * YAML model utility class for handling YAML configuration files
+ */
+export class YamlModel {
+  /**
+   * Parse YAML string to object
+   * @param data - YAML string to parse
+   * @returns Parsed object
+   */
+  public static parse(data: string): any {
+    try {
+      return yaml.load(data);
+    } catch (error: unknown) {
+      throw new Error(`Failed to parse YAML string: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Convert object to YAML string
+   * @param obj - Object to convert
+   * @returns YAML string
+   */
+  public static stringify(obj: any): string {
+    try {
+      // Test for circular references
+      JSON.stringify(obj);
+      return yaml.dump(obj);
+    } catch (error: unknown) {
+      if (error instanceof TypeError && error.message.includes('circular')) {
+        throw new Error('Cannot stringify object with circular references');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Load and parse YAML file
+   * @param path - Path to YAML file
+   * @returns Parsed object
+   */
+  public static async fromFile(path: string): Promise<any> {
+    try {
+      const data = await fs.readFile(path, 'utf-8');
+      return YamlModel.parse(data);
+    } catch (error: unknown) {
+      throw new Error(`Failed to load YAML file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Save object as YAML file
+   * @param obj - Object to save
+   * @param path - Path to save to
+   */
+  public static async toFile(obj: any, path: string): Promise<void> {
+    try {
+      const yaml = YamlModel.stringify(obj);
+      await fs.writeFile(path, yaml);
+    } catch (error: unknown) {
+      throw new Error(`Failed to save YAML file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}