@toyako/hive 1.0.0

package/src/self-healing/LoopMemory.ts

@@ -0,0 +1,98 @@
+/**
+ * LoopMemory — Self-Healing Runtime Phase 2
+ * 
+ * 保存：
+ * - iteration
+ * - failureAnalysis
+ * - evaluation
+ * - recoveryPlan
+ * - plannerFeedback
+ * - runtimeHints
+ * 
+ * 下一轮 Planner 必须收到 Previous Iteration Summary
+ * Loop 必须具备学习能力
+ */
+
+import { FailureAnalysis } from "./FailureClassifier";
+import { RecoveryPlan } from "./PolicyEngine";
+
+// Memory Entry
+export interface MemoryEntry {
+  iteration: number;
+  timestamp: number;
+  failureAnalysis?: FailureAnalysis;
+  evaluation?: any;
+  recoveryPlan?: RecoveryPlan;
+  plannerFeedback?: string;
+  runtimeHints?: string[];
+  result?: any;
+}
+
+export class LoopMemory {
+  private entries: MemoryEntry[] = [];
+
+  /**
+   * 记录迭代
+   */
+  record(entry: Omit<MemoryEntry, "timestamp">): void {
+    this.entries.push({
+      ...entry,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * 获取上一轮摘要
+   */
+  getPreviousIterationSummary(): string {
+    if (this.entries.length === 0) {
+      return "No previous iterations.";
+    }
+
+    const last = this.entries[this.entries.length - 1];
+    const lines: string[] = [
+      `Iteration ${last.iteration}:`,
+      last.failureAnalysis 
+        ? `Failure: ${last.failureAnalysis.type} - ${last.failureAnalysis.reason}`
+        : "No failure",
+      last.recoveryPlan
+        ? `Recovery: ${last.recoveryPlan.action} - ${last.recoveryPlan.reason}`
+        : "No recovery plan",
+      last.plannerFeedback
+        ? `Feedback: ${last.plannerFeedback}`
+        : "No feedback"
+    ];
+
+    return lines.join("\n");
+  }
+
+  /**
+   * 获取所有条目
+   */
+  getEntries(): MemoryEntry[] {
+    return [...this.entries];
+  }
+
+  /**
+   * 获取迭代次数
+   */
+  getIterationCount(): number {
+    return this.entries.length;
+  }
+
+  /**
+   * 获取失败历史
+   */
+  getFailureHistory(): FailureAnalysis[] {
+    return this.entries
+      .filter(e => e.failureAnalysis)
+      .map(e => e.failureAnalysis!);
+  }
+
+  /**
+   * 清空
+   */
+  clear(): void {
+    this.entries = [];
+  }
+}

package/src/self-healing/PolicyEngine.ts

@@ -0,0 +1,117 @@
+/**
+ * PolicyEngine — Self-Healing Runtime Phase 2
+ * 
+ * 职责：根据 FailureType 自动决定恢复策略
+ * 
+ * Failure → Action:
+ * - NETWORK → Retry
+ * - API → Retry
+ * - TIMEOUT → Retry
+ * - TOOL → Retry / Switch Tool
+ * - MODEL → Switch Model
+ * - VALIDATION → Replan
+ * - PLANNER → Replan
+ * - DEPENDENCY → Rollback
+ * - RESOURCE → Wait / Retry
+ * - UNKNOWN → Human Review
+ */
+
+import { FailureType, FailureAnalysis } from "./FailureClassifier";
+
+// Recovery Action
+export type RecoveryAction = 
+  | "RETRY"
+  | "REPLAN"
+  | "SWITCH_MODEL"
+  | "SWITCH_TOOL"
+  | "ROLLBACK"
+  | "WAIT"
+  | "ESCALATE"
+  | "COMPLETE";
+
+// Recovery Plan
+export interface RecoveryPlan {
+  action: RecoveryAction;
+  reason: string;
+  metadata?: Record<string, any>;
+}
+
+export class PolicyEngine {
+  /**
+   * 根据失败分析生成恢复计划
+   */
+  createRecoveryPlan(failure: FailureAnalysis, context?: any): RecoveryPlan {
+    switch (failure.type) {
+      case "NETWORK":
+        return {
+          action: "RETRY",
+          reason: "Network error is transient, retry with backoff",
+          metadata: { backoff: "exponential", maxAttempts: 3 }
+        };
+
+      case "API":
+        return {
+          action: "RETRY",
+          reason: "API error may be transient, retry with backoff",
+          metadata: { backoff: "exponential", maxAttempts: 3 }
+        };
+
+      case "TIMEOUT":
+        return {
+          action: "RETRY",
+          reason: "Timeout may be transient, retry with increased timeout",
+          metadata: { backoff: "exponential", maxAttempts: 2 }
+        };
+
+      case "TOOL":
+        return {
+          action: "SWITCH_TOOL",
+          reason: "Tool failed, try alternative tool",
+          metadata: { originalTool: context?.tool }
+        };
+
+      case "MODEL":
+        return {
+          action: "SWITCH_MODEL",
+          reason: "Model failed, try alternative model",
+          metadata: { originalModel: context?.model }
+        };
+
+      case "VALIDATION":
+        return {
+          action: "REPLAN",
+          reason: "Validation failed, replan with stricter constraints",
+          metadata: { validationErrors: context?.validationErrors }
+        };
+
+      case "PLANNER":
+        return {
+          action: "REPLAN",
+          reason: "Planner failed, replan with different strategy",
+          metadata: { plannerError: failure.reason }
+        };
+
+      case "DEPENDENCY":
+        return {
+          action: "ROLLBACK",
+          reason: "Dependency failed, rollback to last stable state",
+          metadata: { dependency: context?.dependency }
+        };
+
+      case "RESOURCE":
+        return {
+          action: "WAIT",
+          reason: "Resource exhausted, wait and retry",
+          metadata: { waitTime: 5000 }
+        };
+
+      case "UNKNOWN":
+      default:
+        return {
+          action: "ESCALATE",
+          reason: "Unknown failure, escalate to human review",
+          metadata: { failure: failure }
+        };
+    }
+  }
+}

package/src/self-healing/RetryPolicy.ts

@@ -0,0 +1,120 @@
+/**
+ * RetryPolicy — Self-Healing Runtime Phase 2
+ * 
+ * 支持：
+ * - maxAttempts
+ * - backoff: exponential, linear, fixed
+ * - jitter
+ * - retryableErrors
+ * 
+ * 禁止无限 Retry
+ */
+
+// Retry Config
+export interface RetryConfig {
+  maxAttempts: number;
+  backoff: "exponential" | "linear" | "fixed";
+  baseDelay: number; // ms
+  maxDelay: number; // ms
+  jitter: boolean;
+  retryableErrors: string[];
+}
+
+// Retry State
+export interface RetryState {
+  attempt: number;
+  totalDelay: number;
+  lastError?: string;
+}
+
+export class RetryPolicy {
+  private config: RetryConfig;
+  private state: RetryState;
+
+  constructor(config: Partial<RetryConfig> = {}) {
+    this.config = {
+      maxAttempts: 3,
+      backoff: "exponential",
+      baseDelay: 1000,
+      maxDelay: 10000,
+      jitter: true,
+      retryableErrors: ["NETWORK", "API", "TIMEOUT"],
+      ...config
+    };
+
+    this.state = {
+      attempt: 0,
+      totalDelay: 0
+    };
+  }
+
+  /**
+   * 是否可以重试
+   */
+  canRetry(errorType: string): boolean {
+    if (this.state.attempt >= this.config.maxAttempts) {
+      return false;
+    }
+
+    if (!this.config.retryableErrors.includes(errorType)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 获取重试延迟
+   */
+  getDelay(): number {
+    let delay: number;
+
+    switch (this.config.backoff) {
+      case "exponential":
+        delay = this.config.baseDelay * Math.pow(2, this.state.attempt);
+        break;
+      case "linear":
+        delay = this.config.baseDelay * (this.state.attempt + 1);
+        break;
+      case "fixed":
+      default:
+        delay = this.config.baseDelay;
+    }
+
+    // 应用最大延迟
+    delay = Math.min(delay, this.config.maxDelay);
+
+    // 应用 jitter
+    if (this.config.jitter) {
+      delay = delay * (0.5 + Math.random() * 0.5);
+    }
+
+    return Math.floor(delay);
+  }
+
+  /**
+   * 记录重试
+   */
+  recordRetry(error: string): void {
+    this.state.attempt++;
+    this.state.lastError = error;
+    this.state.totalDelay += this.getDelay();
+  }
+
+  /**
+   * 获取状态
+   */
+  getState(): RetryState {
+    return { ...this.state };
+  }
+
+  /**
+   * 重置
+   */
+  reset(): void {
+    this.state = {
+      attempt: 0,
+      totalDelay: 0
+    };
+  }
+}

package/src/self-healing/RuntimeEvents.ts

@@ -0,0 +1,93 @@
+/**
+ * RuntimeEvents — Self-Healing Runtime Phase 2
+ * 
+ * 统一事件：
+ * - TASK_STARTED
+ * - NODE_STARTED
+ * - NODE_COMPLETED
+ * - NODE_FAILED
+ * - NODE_RETRY
+ * - NODE_REPLAN
+ * - LOOP_STARTED
+ * - LOOP_COMPLETED
+ * - LOOP_FAILED
+ * - TASK_COMPLETED
+ * 
+ * 全部进入 EventBus
+ */
+
+// Event Type
+export type RuntimeEventType = 
+  | "TASK_STARTED"
+  | "NODE_STARTED"
+  | "NODE_COMPLETED"
+  | "NODE_FAILED"
+  | "NODE_RETRY"
+  | "NODE_REPLAN"
+  | "LOOP_STARTED"
+  | "LOOP_COMPLETED"
+  | "LOOP_FAILED"
+  | "TASK_COMPLETED";
+
+// Runtime Event
+export interface RuntimeEvent {
+  type: RuntimeEventType;
+  timestamp: number;
+  executionId: string;
+  nodeId?: string;
+  data?: any;
+}
+
+export class RuntimeEventEmitter {
+  private events: RuntimeEvent[] = [];
+  private listeners: Map<RuntimeEventType, Function[]> = new Map();
+
+  /**
+   * 发送事件
+   */
+  emit(event: Omit<RuntimeEvent, "timestamp">): void {
+    const fullEvent: RuntimeEvent = {
+      ...event,
+      timestamp: Date.now()
+    };
+
+    this.events.push(fullEvent);
+
+    // 通知监听器
+    const listeners = this.listeners.get(event.type) || [];
+    for (const listener of listeners) {
+      listener(fullEvent);
+    }
+  }
+
+  /**
+   * 监听事件
+   */
+  on(type: RuntimeEventType, listener: (event: RuntimeEvent) => void): void {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, []);
+    }
+    this.listeners.get(type)!.push(listener);
+  }
+
+  /**
+   * 获取所有事件
+   */
+  getEvents(): RuntimeEvent[] {
+    return [...this.events];
+  }
+
+  /**
+   * 获取指定类型的事件
+   */
+  getEventsByType(type: RuntimeEventType): RuntimeEvent[] {
+    return this.events.filter(e => e.type === type);
+  }
+
+  /**
+   * 清空事件
+   */
+  clear(): void {
+    this.events = [];
+  }
+}

package/src/self-healing/SelfHealingRuntime.ts

@@ -0,0 +1,282 @@
+/**
+ * SelfHealingRuntime — Self-Healing Runtime Phase 2
+ * 
+ * 将所有组件整合为一个完整的自愈运行时
+ */
+
+import { FailureClassifier, FailureAnalysis } from "./FailureClassifier";
+import { PolicyEngine, RecoveryPlan, RecoveryAction } from "./PolicyEngine";
+import { RetryPolicy } from "./RetryPolicy";
+import { LoopMemory } from "./LoopMemory";
+import { ExecutionTrace } from "./ExecutionTrace";
+import { RuntimeEventEmitter, RuntimeEventType } from "./RuntimeEvents";
+import { RuntimeV2 } from "../runtime-v2";
+import { ObservationEngine, Observation } from "../loop-layer/ObservationEngine";
+import { EvaluationEngine, Evaluation } from "../loop-layer/EvaluationEngine";
+
+// Self-Healing Result
+export interface SelfHealingResult {
+  success: boolean;
+  iterations: number;
+  finalEvaluation: Evaluation;
+  trace: ExecutionTrace;
+  memory: LoopMemory;
+}
+
+export class SelfHealingRuntime {
+  private runtime: RuntimeV2;
+  private failureClassifier: FailureClassifier;
+  private policyEngine: PolicyEngine;
+  private retryPolicy: RetryPolicy;
+  private loopMemory: LoopMemory;
+  private observationEngine: ObservationEngine;
+  private evaluationEngine: EvaluationEngine;
+  private eventEmitter: RuntimeEventEmitter;
+  private maxIterations: number;
+
+  constructor(maxIterations: number = 5) {
+    this.runtime = new RuntimeV2();
+    this.failureClassifier = new FailureClassifier();
+    this.policyEngine = new PolicyEngine();
+    this.retryPolicy = new RetryPolicy();
+    this.loopMemory = new LoopMemory();
+    this.observationEngine = new ObservationEngine();
+    this.evaluationEngine = new EvaluationEngine();
+    this.eventEmitter = new RuntimeEventEmitter();
+    this.maxIterations = maxIterations;
+  }
+
+  /**
+   * 执行任务（自愈）
+   */
+  async execute(task: string): Promise<SelfHealingResult> {
+    const executionId = `self-healing-${Date.now()}`;
+    const trace = new ExecutionTrace(executionId);
+    let iteration = 0;
+    let currentTask = task;
+
+    this.eventEmitter.emit({
+      type: "TASK_STARTED",
+      executionId,
+      data: { task }
+    });
+
+    while (iteration < this.maxIterations) {
+      iteration++;
+      const nodeId = `iteration-${iteration}`;
+
+      this.eventEmitter.emit({
+        type: "LOOP_STARTED",
+        executionId,
+        nodeId,
+        data: { iteration }
+      });
+
+      trace.startNode(nodeId, { task: currentTask });
+
+      try {
+        // 执行 Runtime
+        const startTime = Date.now();
+        const result = await this.runtime.run(currentTask);
+        const duration = Date.now() - startTime;
+
+        // 观察结果
+        const observation = this.observationEngine.observe(nodeId, result, startTime);
+
+        // 评估结果
+        const evaluation = this.evaluationEngine.evaluate(observation);
+
+        // 记录到内存
+        this.loopMemory.record({
+          iteration,
+          result,
+          evaluation
+        });
+
+        trace.completeNode(nodeId, result);
+
+        this.eventEmitter.emit({
+          type: "NODE_COMPLETED",
+          executionId,
+          nodeId,
+          data: { result }
+        });
+
+        // 检查是否成功
+        if (evaluation.status === "SUCCESS") {
+          this.eventEmitter.emit({
+            type: "TASK_COMPLETED",
+            executionId,
+            data: { iterations: iteration }
+          });
+
+          return {
+            success: true,
+            iterations: iteration,
+            finalEvaluation: evaluation,
+            trace,
+            memory: this.loopMemory
+          };
+        }
+
+        // 失败处理
+        const failure: FailureAnalysis = {
+          type: "UNKNOWN",
+          confidence: 0.5,
+          reason: evaluation.reason
+        };
+
+        const recoveryPlan = this.policyEngine.createRecoveryPlan(failure);
+
+        this.loopMemory.record({
+          iteration,
+          failureAnalysis: failure,
+          recoveryPlan
+        });
+
+        // 根据恢复计划执行
+        switch (recoveryPlan.action) {
+          case "RETRY":
+            trace.retryNode(nodeId);
+            this.eventEmitter.emit({
+              type: "NODE_RETRY",
+              executionId,
+              nodeId,
+              data: { recoveryPlan }
+            });
+            break;
+
+          case "REPLAN":
+            currentTask = `Replan: ${task} (attempt ${iteration})`;
+            this.eventEmitter.emit({
+              type: "NODE_REPLAN",
+              executionId,
+              nodeId,
+              data: { recoveryPlan }
+            });
+            break;
+
+          case "ESCALATE":
+          default:
+            this.eventEmitter.emit({
+              type: "LOOP_FAILED",
+              executionId,
+              nodeId,
+              data: { reason: "Escalated to human" }
+            });
+
+            return {
+              success: false,
+              iterations: iteration,
+              finalEvaluation: evaluation,
+              trace,
+              memory: this.loopMemory
+            };
+        }
+
+      } catch (error) {
+        // 失败分类
+        const failure = this.failureClassifier.classify(error);
+        const recoveryPlan = this.policyEngine.createRecoveryPlan(failure);
+
+        trace.failNode(nodeId, String(error), failure.type);
+
+        this.eventEmitter.emit({
+          type: "NODE_FAILED",
+          executionId,
+          nodeId,
+          data: { failure, recoveryPlan }
+        });
+
+        this.loopMemory.record({
+          iteration,
+          failureAnalysis: failure,
+          recoveryPlan
+        });
+
+        // 根据恢复计划执行
+        switch (recoveryPlan.action) {
+          case "RETRY":
+            if (this.retryPolicy.canRetry(failure.type)) {
+              const delay = this.retryPolicy.getDelay();
+              this.retryPolicy.recordRetry(failure.reason);
+              
+              trace.retryNode(nodeId);
+              await this.delay(delay);
+              
+              this.eventEmitter.emit({
+                type: "NODE_RETRY",
+                executionId,
+                nodeId,
+                data: { delay }
+              });
+            } else {
+              return {
+                success: false,
+                iterations: iteration,
+                finalEvaluation: {
+                  status: "FAILED",
+                  reason: "Max retries exceeded",
+                  nextAction: "COMPLETE"
+                },
+                trace,
+                memory: this.loopMemory
+              };
+            }
+            break;
+
+          case "REPLAN":
+            currentTask = `Replan: ${task} (attempt ${iteration})`;
+            this.eventEmitter.emit({
+              type: "NODE_REPLAN",
+              executionId,
+              nodeId,
+              data: { recoveryPlan }
+            });
+            break;
+
+          case "ESCALATE":
+          default:
+            return {
+              success: false,
+              iterations: iteration,
+              finalEvaluation: {
+                status: "FAILED",
+                reason: failure.reason,
+                nextAction: "COMPLETE"
+              },
+              trace,
+              memory: this.loopMemory
+            };
+        }
+      }
+    }
+
+    // 超过最大迭代次数
+    return {
+      success: false,
+      iterations: iteration,
+      finalEvaluation: {
+        status: "FAILED",
+        reason: "LOOP_LIMIT_EXCEEDED",
+        nextAction: "COMPLETE"
+      },
+      trace,
+      memory: this.loopMemory
+    };
+  }
+
+  /**
+   * 获取事件发射器
+   */
+  getEventEmitter(): RuntimeEventEmitter {
+    return this.eventEmitter;
+  }
+
+  /**
+   * 延迟
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}