@toyako/hive 1.0.0

package/src/evolution/EvolutionEngine.ts

@@ -0,0 +1,388 @@
+/**
+ * Autonomous Engineering Evolution System — v6.0
+ * 
+ * System is no longer static.
+ * System is now a self-modifying engineering organism.
+ * 
+ * Evolution Loop:
+ * Observe System State → Detect Inefficiencies → Generate Architecture Hypothesis
+ * → Simulate Impact → Apply Controlled Evolution → Validate Stability → Commit New System Version
+ * 
+ * Core Principle:
+ * The system is not built once.
+ * The system is continuously engineered by itself.
+ */
+
+// ═══════════════════════════════════════════════════════════════
+// Module 1: Architecture Intelligence Engine
+// ═══════════════════════════════════════════════════════════════
+
+// Inefficiency
+export interface Inefficiency {
+  type: "REDUNDANCY" | "COUPLING" | "MISSING_ABSTRACTION" | "COMPLEXITY";
+  location: string;
+  description: string;
+  severity: "low" | "medium" | "high";
+  impact: number; // 0-1
+}
+
+export class ArchitectureIntelligenceEngine {
+  /**
+   * 检测系统低效
+   */
+  detectInefficiencies(systemState: any): Inefficiency[] {
+    const inefficiencies: Inefficiency[] = [];
+
+    // 检测冗余
+    if (systemState.duplicateModules && systemState.duplicateModules.length > 0) {
+      for (const module of systemState.duplicateModules) {
+        inefficiencies.push({
+          type: "REDUNDANCY",
+          location: module,
+          description: `Duplicate module: ${module}`,
+          severity: "medium",
+          impact: 0.5
+        });
+      }
+    }
+
+    // 检测耦合
+    if (systemState.couplingScore && systemState.couplingScore > 0.7) {
+      inefficiencies.push({
+        type: "COUPLING",
+        location: "system-wide",
+        description: "High coupling between modules",
+        severity: "high",
+        impact: 0.8
+      });
+    }
+
+    // 检测缺失抽象
+    if (systemState.missingAbstractions && systemState.missingAbstractions.length > 0) {
+      for (const abstraction of systemState.missingAbstractions) {
+        inefficiencies.push({
+          type: "MISSING_ABSTRACTION",
+          location: abstraction,
+          description: `Missing abstraction: ${abstraction}`,
+          severity: "medium",
+          impact: 0.6
+        });
+      }
+    }
+
+    // 检测复杂度
+    if (systemState.complexityScore && systemState.complexityScore > 0.8) {
+      inefficiencies.push({
+        type: "COMPLEXITY",
+        location: "system-wide",
+        description: "System complexity too high",
+        severity: "high",
+        impact: 0.9
+      });
+    }
+
+    return inefficiencies;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Module 2: Evolution Planner
+// ═══════════════════════════════════════════════════════════════
+
+// Evolution Proposal
+export interface EvolutionProposal {
+  id: string;
+  type: "MERGE" | "SPLIT" | "EXTRACT" | "REFACTOR" | "ABSTRACT";
+  target: string;
+  description: string;
+  expectedImpact: number; // 0-1
+  risk: "low" | "medium" | "high";
+  priority: number; // 1-10
+}
+
+export class EvolutionPlanner {
+  /**
+   * 生成演化提案
+   */
+  propose(inefficiencies: Inefficiency[]): EvolutionProposal[] {
+    const proposals: EvolutionProposal[] = [];
+
+    for (const inefficiency of inefficiencies) {
+      switch (inefficiency.type) {
+        case "REDUNDANCY":
+          proposals.push({
+            id: `prop-${Date.now()}-merge`,
+            type: "MERGE",
+            target: inefficiency.location,
+            description: `Merge duplicate modules at ${inefficiency.location}`,
+            expectedImpact: inefficiency.impact,
+            risk: "low",
+            priority: 7
+          });
+          break;
+
+        case "COUPLING":
+          proposals.push({
+            id: `prop-${Date.now()}-extract`,
+            type: "EXTRACT",
+            target: inefficiency.location,
+            description: "Extract shared interfaces to reduce coupling",
+            expectedImpact: inefficiency.impact,
+            risk: "medium",
+            priority: 8
+          });
+          break;
+
+        case "MISSING_ABSTRACTION":
+          proposals.push({
+            id: `prop-${Date.now()}-abstract`,
+            type: "ABSTRACT",
+            target: inefficiency.location,
+            description: `Create abstraction layer for ${inefficiency.location}`,
+            expectedImpact: inefficiency.impact,
+            risk: "low",
+            priority: 6
+          });
+          break;
+
+        case "COMPLEXITY":
+          proposals.push({
+            id: `prop-${Date.now()}-refactor`,
+            type: "REFACTOR",
+            target: inefficiency.location,
+            description: "Refactor to reduce complexity",
+            expectedImpact: inefficiency.impact,
+            risk: "medium",
+            priority: 9
+          });
+          break;
+      }
+    }
+
+    // 按优先级排序
+    return proposals.sort((a, b) => b.priority - a.priority);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Module 3: Simulation Sandbox
+// ═══════════════════════════════════════════════════════════════
+
+// Simulation Result
+export interface SimulationResult {
+  proposalId: string;
+  success: boolean;
+  predictedImpact: number;
+  sideEffects: string[];
+  confidence: number;
+}
+
+export class SimulationSandbox {
+  /**
+   * 模拟架构变化影响
+   */
+  simulate(proposal: EvolutionProposal, currentState: any): SimulationResult {
+    // 简化模拟
+    const sideEffects: string[] = [];
+    let predictedImpact = proposal.expectedImpact;
+
+    // 检查副作用
+    if (proposal.type === "MERGE") {
+      sideEffects.push("May affect dependent modules");
+      predictedImpact *= 0.9;
+    }
+
+    if (proposal.type === "REFACTOR") {
+      sideEffects.push("May require test updates");
+      predictedImpact *= 0.8;
+    }
+
+    if (proposal.risk === "high") {
+      sideEffects.push("High risk of regression");
+      predictedImpact *= 0.7;
+    }
+
+    return {
+      proposalId: proposal.id,
+      success: predictedImpact > 0.5,
+      predictedImpact,
+      sideEffects,
+      confidence: 0.8
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Module 4: Controlled Mutation Gate
+// ═══════════════════════════════════════════════════════════════
+
+// Mutation Decision
+export interface MutationDecision {
+  allowed: boolean;
+  reason: string;
+  conditions: string[];
+}
+
+export class ControlledMutationGate {
+  private stabilityThreshold: number;
+  private maxRiskLevel: "low" | "medium" | "high";
+
+  constructor(stabilityThreshold: number = 0.7, maxRiskLevel: "low" | "medium" | "high" = "medium") {
+    this.stabilityThreshold = stabilityThreshold;
+    this.maxRiskLevel = maxRiskLevel;
+  }
+
+  /**
+   * 检查是否允许变异
+   */
+  check(proposal: EvolutionProposal, simulation: SimulationResult): MutationDecision {
+    const conditions: string[] = [];
+
+    // 检查稳定性
+    if (simulation.predictedImpact < this.stabilityThreshold) {
+      conditions.push(`Impact too low: ${simulation.predictedImpact.toFixed(2)}`);
+    }
+
+    // 检查风险
+    const riskOrder = { low: 0, medium: 1, high: 2 };
+    if (riskOrder[proposal.risk] > riskOrder[this.maxRiskLevel]) {
+      conditions.push(`Risk too high: ${proposal.risk}`);
+    }
+
+    // 检查置信度
+    if (simulation.confidence < 0.6) {
+      conditions.push(`Confidence too low: ${simulation.confidence.toFixed(2)}`);
+    }
+
+    // 检查副作用
+    if (simulation.sideEffects.length > 2) {
+      conditions.push(`Too many side effects: ${simulation.sideEffects.length}`);
+    }
+
+    return {
+      allowed: conditions.length === 0,
+      reason: conditions.length === 0 ? "All checks passed" : conditions.join(", "),
+      conditions
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Module 5: Versioned Architecture Memory
+// ═══════════════════════════════════════════════════════════════
+
+// Architecture Version
+export interface ArchitectureVersion {
+  version: string;
+  timestamp: number;
+  changes: string[];
+  state: any;
+  stability: number;
+}
+
+export class VersionedArchitectureMemory {
+  private versions: ArchitectureVersion[] = [];
+
+  /**
+   * 记录架构版本
+   */
+  record(version: ArchitectureVersion): void {
+    this.versions.push(version);
+  }
+
+  /**
+   * 获取最新版本
+   */
+  latest(): ArchitectureVersion | undefined {
+    return this.versions[this.versions.length - 1];
+  }
+
+  /**
+   * 获取所有版本
+   */
+  getAll(): ArchitectureVersion[] {
+    return [...this.versions];
+  }
+
+  /**
+   * 获取版本历史
+   */
+  history(): { version: string; timestamp: number; stability: number }[] {
+    return this.versions.map(v => ({
+      version: v.version,
+      timestamp: v.timestamp,
+      stability: v.stability
+    }));
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Evolution Engine (Orchestrator)
+// ═══════════════════════════════════════════════════════════════
+
+export class EvolutionEngine {
+  private intelligence: ArchitectureIntelligenceEngine;
+  private planner: EvolutionPlanner;
+  private sandbox: SimulationSandbox;
+  private gate: ControlledMutationGate;
+  private memory: VersionedArchitectureMemory;
+
+  constructor() {
+    this.intelligence = new ArchitectureIntelligenceEngine();
+    this.planner = new EvolutionPlanner();
+    this.sandbox = new SimulationSandbox();
+    this.gate = new ControlledMutationGate();
+    this.memory = new VersionedArchitectureMemory();
+  }
+
+  /**
+   * 执行演化循环
+   */
+  evolve(systemState: any): {
+    inefficiencies: Inefficiency[];
+    proposals: EvolutionProposal[];
+    approved: EvolutionProposal[];
+    rejected: EvolutionProposal[];
+  } {
+    // 1. 检测低效
+    const inefficiencies = this.intelligence.detectInefficiencies(systemState);
+
+    // 2. 生成提案
+    const proposals = this.planner.propose(inefficiencies);
+
+    // 3. 模拟并过滤
+    const approved: EvolutionProposal[] = [];
+    const rejected: EvolutionProposal[] = [];
+
+    for (const proposal of proposals) {
+      const simulation = this.sandbox.simulate(proposal, systemState);
+      const decision = this.gate.check(proposal, simulation);
+
+      if (decision.allowed) {
+        approved.push(proposal);
+      } else {
+        rejected.push(proposal);
+      }
+    }
+
+    // 4. 记录版本
+    if (approved.length > 0) {
+      this.memory.record({
+        version: `v${this.memory.getAll().length + 1}`,
+        timestamp: Date.now(),
+        changes: approved.map(p => p.description),
+        state: systemState,
+        stability: 0.9
+      });
+    }
+
+    return { inefficiencies, proposals, approved, rejected };
+  }
+
+  /**
+   * 获取演化历史
+   */
+  getHistory(): ArchitectureVersion[] {
+    return this.memory.getAll();
+  }
+}

package/src/evolution/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Autonomous Engineering Evolution System — v6.0
+ * 
+ * System is no longer static.
+ * System is now a self-modifying engineering organism.
+ * 
+ * Evolution Loop:
+ * Observe → Detect → Propose → Simulate → Apply → Validate → Commit
+ * 
+ * Core Principle:
+ * The system is not built once.
+ * The system is continuously engineered by itself.
+ */
+
+export {
+  Inefficiency,
+  ArchitectureIntelligenceEngine,
+  EvolutionProposal,
+  EvolutionPlanner,
+  SimulationResult,
+  SimulationSandbox,
+  MutationDecision,
+  ControlledMutationGate,
+  ArchitectureVersion,
+  VersionedArchitectureMemory,
+  EvolutionEngine
+} from "./EvolutionEngine";

package/src/execution-fabric/DistributedExecutionFabric.ts

@@ -0,0 +1,304 @@
+/**
+ * Distributed Execution Fabric v2.0
+ * 
+ * 从"single-node runtime" → "distributed execution fabric (multi-node, event-driven, fault-tolerant)"
+ * 
+ * 系统工程定义：
+ * "event-driven distributed execution fabric for AI workflows"
+ * 
+ * 核心组件：
+ * - Global Scheduler: 任务分发、node placement、load balancing
+ * - Execution Nodes: 独立worker集群
+ * - Coordination Layer: 路由任务、维护DAG一致性、处理node failure
+ * - Distributed Event Log: 分布式事件流
+ * - State Replication Layer: 跨节点状态同步
+ * - Global Control Plane: 跨节点治理
+ */
+
+// Execution Node
+export interface ExecutionNode {
+  id: string;
+  capacity: number;
+  currentLoad: number;
+  status: "healthy" | "overloaded" | "failing";
+  workers: { planner: number; executor: number; validator: number };
+}
+
+// Distributed Task
+export interface DistributedTask {
+  id: string;
+  priority: number;
+  dependencies: string[];
+  assignedNode?: string;
+  status: "pending" | "assigned" | "running" | "done" | "failed" | "migrated";
+  type: "planner" | "executor" | "validator";
+  input: any;
+  output?: any;
+}
+
+// Fabric Event
+export interface FabricEvent {
+  event_id: string;
+  node_id: string;
+  task_id: string;
+  type: "EXEC" | "FAIL" | "MIGRATE" | "COMPLETE" | "NODE_HEALTH";
+  payload: any;
+  timestamp: number;
+}
+
+// Node Assignment
+export interface NodeAssignment {
+  task_id: string;
+  node_id: string;
+  reason: string;
+  score: number;
+}
+
+export class DistributedExecutionFabric {
+  private nodes: Map<string, ExecutionNode> = new Map();
+  private tasks: Map<string, DistributedTask> = new Map();
+  private eventLog: FabricEvent[] = [];
+  private assignments: NodeAssignment[] = [];
+
+  constructor() {
+    this.initializeNodes();
+  }
+
+  /**
+   * 初始化执行节点
+   */
+  private initializeNodes(): void {
+    this.addNode({
+      id: "node-a",
+      capacity: 10,
+      currentLoad: 0,
+      status: "healthy",
+      workers: { planner: 2, executor: 4, validator: 2 }
+    });
+
+    this.addNode({
+      id: "node-b",
+      capacity: 10,
+      currentLoad: 0,
+      status: "healthy",
+      workers: { planner: 2, executor: 4, validator: 2 }
+    });
+  }
+
+  /**
+   * 添加节点
+   */
+  addNode(node: ExecutionNode): void {
+    this.nodes.set(node.id, node);
+  }
+
+  /**
+   * 提交任务
+   */
+  submitTask(task: Omit<DistributedTask, "status" | "assignedNode">): DistributedTask {
+    const fullTask: DistributedTask = {
+      ...task,
+      status: "pending"
+    };
+
+    this.tasks.set(task.id, fullTask);
+    this.recordEvent("global", task.id, "EXEC", { action: "submitted" });
+    return fullTask;
+  }
+
+  /**
+   * 执行 fabric cycle
+   */
+  async execute(): Promise<{
+    completed: string[];
+    failed: string[];
+    migrated: string[];
+    healthScore: number;
+  }> {
+    const completed: string[] = [];
+    const failed: string[] = [];
+    const migrated: string[] = [];
+
+    // Step 2: Graph Partitioning
+    const subgraphs = this.partitionGraph();
+
+    // Step 3: Node Assignment
+    for (const [nodeId, tasks] of subgraphs) {
+      for (const task of tasks) {
+        const assignment = this.assignTask(task, nodeId);
+        this.assignments.push(assignment);
+      }
+    }
+
+    // Step 4: Distributed Execution
+    for (const task of this.tasks.values()) {
+      if (task.status !== "pending") continue;
+
+      // 检查依赖
+      const allDepsComplete = task.dependencies.every(depId => {
+        const dep = this.tasks.get(depId);
+        return dep?.status === "done";
+      });
+
+      if (!allDepsComplete) continue;
+
+      // 找到分配的节点
+      const assignment = this.assignments.find(a => a.task_id === task.id);
+      if (!assignment) continue;
+
+      const node = this.nodes.get(assignment.node_id);
+      if (!node) continue;
+
+      // 检查节点健康
+      if (node.status === "failing") {
+        // 迁移任务
+        const newNode = this.findHealthyNode();
+        if (newNode) {
+          task.assignedNode = newNode.id;
+          task.status = "migrated";
+          migrated.push(task.id);
+          this.recordEvent(newNode.id, task.id, "MIGRATE", { from: node.id });
+          continue;
+        }
+      }
+
+      // 执行
+      task.assignedNode = node.id;
+      task.status = "running";
+      node.currentLoad++;
+
+      try {
+        // 模拟执行
+        task.output = { result: `Executed ${task.id}` };
+        task.status = "done";
+        completed.push(task.id);
+        node.currentLoad--;
+
+        this.recordEvent(node.id, task.id, "COMPLETE", { output: task.output });
+      } catch (error: any) {
+        task.status = "failed";
+        failed.push(task.id);
+        node.currentLoad--;
+
+        this.recordEvent(node.id, task.id, "FAIL", { error: error.message });
+      }
+    }
+
+    // 计算健康分数
+    const healthScore = this.calculateHealthScore();
+
+    return { completed, failed, migrated, healthScore };
+  }
+
+  /**
+   * 图分区
+   */
+  private partitionGraph(): Map<string, DistributedTask[]> {
+    const subgraphs = new Map<string, DistributedTask[]>();
+    const nodeIds = Array.from(this.nodes.keys());
+
+    // 简单轮询分配
+    let index = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status !== "pending") continue;
+
+      const nodeId = nodeIds[index % nodeIds.length];
+      if (!subgraphs.has(nodeId)) {
+        subgraphs.set(nodeId, []);
+      }
+      subgraphs.get(nodeId)!.push(task);
+      index++;
+    }
+
+    return subgraphs;
+  }
+
+  /**
+   * 分配任务
+   */
+  private assignTask(task: DistributedTask, nodeId: string): NodeAssignment {
+    const node = this.nodes.get(nodeId)!;
+    const score = task.priority + node.capacity - node.currentLoad;
+
+    task.assignedNode = nodeId;
+    task.status = "assigned";
+
+    return {
+      task_id: task.id,
+      node_id: nodeId,
+      reason: "load-balanced",
+      score
+    };
+  }
+
+  /**
+   * 找到健康节点
+   */
+  private findHealthyNode(): ExecutionNode | undefined {
+    for (const node of this.nodes.values()) {
+      if (node.status === "healthy" && node.currentLoad < node.capacity) {
+        return node;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * 计算健康分数
+   */
+  private calculateHealthScore(): number {
+    const nodes = Array.from(this.nodes.values());
+    const healthyNodes = nodes.filter(n => n.status === "healthy").length;
+    return nodes.length > 0 ? healthyNodes / nodes.length : 0;
+  }
+
+  /**
+   * 记录事件
+   */
+  private recordEvent(nodeId: string, taskId: string, type: FabricEvent["type"], payload: any): void {
+    this.eventLog.push({
+      event_id: `evt-${Date.now().toString(36)}`,
+      node_id: nodeId,
+      task_id: taskId,
+      type,
+      payload,
+      timestamp: Date.now()
+    });
+  }
+
+  /**
+   * 获取事件日志
+   */
+  getEventLog(): FabricEvent[] {
+    return [...this.eventLog];
+  }
+
+  /**
+   * 格式化输出
+   */
+  format(): string {
+    const lines: string[] = [];
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    lines.push("Distributed Execution Fabric v2.0");
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    lines.push("");
+    lines.push("Nodes:");
+    for (const node of this.nodes.values()) {
+      const status = node.status === "healthy" ? "✅" : node.status === "overloaded" ? "⚠️" : "❌";
+      lines.push(`  ${status} ${node.id} (load: ${node.currentLoad}/${node.capacity})`);
+    }
+    lines.push("");
+    lines.push("Tasks:");
+    for (const task of this.tasks.values()) {
+      const status = task.status === "done" ? "✅" : task.status === "failed" ? "❌" : task.status === "migrated" ? "🔄" : "⏳";
+      lines.push(`  ${status} ${task.id} → ${task.assignedNode || "unassigned"}`);
+    }
+    lines.push("");
+    lines.push(`Events: ${this.eventLog.length}`);
+    lines.push(`Assignments: ${this.assignments.length}`);
+    lines.push("");
+    lines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+
+    return lines.join("\n");
+  }
+}