@toyako/hive 1.0.0

package/src/reasoning/TradeoffReasoningEngine.ts

@@ -0,0 +1,114 @@
+/**
+ * Trade-off Reasoning Engine — Architecture Reasoning Layer 4
+ * 
+ * 输出结构化 reasoning
+ * 
+ * 必须包含：
+ * - scalability risk
+ * - deployment complexity
+ * - maintenance cost
+ * - failure surface area
+ */
+
+import { ArchitectureCandidate } from "./ArchitectureCandidateGenerator";
+
+// Trade-off Analysis
+export interface TradeoffAnalysis {
+  pros: string[];
+  cons: string[];
+  risks: string[];
+  unknowns: string[];
+}
+
+export class TradeoffReasoningEngine {
+  /**
+   * 分析候选架构的权衡
+   */
+  analyze(candidate: ArchitectureCandidate): TradeoffAnalysis {
+    const [pattern, db, backend] = candidate.type.split("+");
+
+    return {
+      pros: this.getPros(pattern, db, backend),
+      cons: this.getCons(pattern, db, backend),
+      risks: this.getRisks(pattern, db, backend),
+      unknowns: this.getUnknowns(pattern, db, backend)
+    };
+  }
+
+  private getPros(pattern: string, db: string, backend: string): string[] {
+    const pros: string[] = [];
+
+    if (pattern === "monolith") {
+      pros.push("Simple deployment", "Easy debugging", "Low operational cost");
+    }
+    if (pattern === "modular-monolith") {
+      pros.push("Good separation of concerns", "Easy to refactor", "Single deployment");
+    }
+    if (pattern === "microservices") {
+      pros.push("Independent scaling", "Technology flexibility", "Team autonomy");
+    }
+    if (db === "postgres") {
+      pros.push("ACID compliance", "Rich feature set", "Strong ecosystem");
+    }
+    if (backend === "nestjs") {
+      pros.push("TypeScript native", "Good architecture patterns", "Enterprise ready");
+    }
+
+    return pros;
+  }
+
+  private getCons(pattern: string, db: string, backend: string): string[] {
+    const cons: string[] = [];
+
+    if (pattern === "monolith") {
+      cons.push("Scaling limitations", "Technology lock-in", "Long build times");
+    }
+    if (pattern === "microservices") {
+      cons.push("Operational complexity", "Network overhead", "Distributed debugging");
+    }
+    if (db === "sqlite") {
+      cons.push("No concurrent writes", "Single server only", "Limited scalability");
+    }
+
+    return cons;
+  }
+
+  private getRisks(pattern: string, db: string, backend: string): string[] {
+    const risks: string[] = [];
+
+    // Scalability risk
+    if (pattern === "monolith") {
+      risks.push("May hit scaling ceiling with growth");
+    }
+
+    // Deployment complexity
+    if (pattern === "microservices") {
+      risks.push("Requires container orchestration expertise");
+    }
+
+    // Maintenance cost
+    if (db === "mongodb") {
+      risks.push("Schema migration complexity");
+    }
+
+    // Failure surface area
+    if (pattern === "microservices") {
+      risks.push("More failure points, requires circuit breakers");
+    }
+
+    return risks;
+  }
+
+  private getUnknowns(pattern: string, db: string, backend: string): string[] {
+    const unknowns: string[] = [];
+
+    if (pattern === "microservices") {
+      unknowns.push("Actual latency overhead", "Service discovery complexity");
+    }
+    if (db === "mongodb") {
+      unknowns.push("Query performance for complex joins");
+    }
+
+    return unknowns;
+  }
+}

package/src/reasoning/index.ts

@@ -0,0 +1,115 @@
+/**
+ * Architecture Reasoning Engine v1
+ * 
+ * Intent + Domain + Constraints
+ *   ↓
+ * Architecture Candidates
+ *   ↓
+ * Reasoned Evaluation (constraints + simulation)
+ *   ↓
+ * Explainable Architecture Decision
+ * 
+ * 系统本质升级：
+ * Before: Architecture = output
+ * After: Architecture = reasoning result over constrained space + simulation + decision trace
+ */
+
+import { ConstraintInferenceEngine, Constraints } from "./ConstraintInferenceEngine";
+import { ArchitectureSpaceGenerator, ArchitectureSpace } from "./ArchitectureSpaceGenerator";
+import { ArchitectureCandidateGenerator, ArchitectureCandidate } from "./ArchitectureCandidateGenerator";
+import { TradeoffReasoningEngine, TradeoffAnalysis } from "./TradeoffReasoningEngine";
+import { FailureSimulationEngine, FailureSimulation } from "./FailureSimulationEngine";
+import { DecisionEngine, ArchitectureDecision } from "./DecisionEngine";
+import { ExplainabilityLayer, ArchitectureExplanation } from "./ExplainabilityLayer";
+
+// Reasoning Result
+export interface ReasoningResult {
+  constraints: Constraints;
+  space: ArchitectureSpace;
+  candidates: ArchitectureCandidate[];
+  tradeoffs: Map<string, TradeoffAnalysis>;
+  simulations: Map<string, FailureSimulation>;
+  decision: ArchitectureDecision;
+  explanation: ArchitectureExplanation;
+}
+
+export class ArchitectureReasoningEngine {
+  private constraintEngine: ConstraintInferenceEngine;
+  private spaceGenerator: ArchitectureSpaceGenerator;
+  private candidateGenerator: ArchitectureCandidateGenerator;
+  private tradeoffEngine: TradeoffReasoningEngine;
+  private simulationEngine: FailureSimulationEngine;
+  private decisionEngine: DecisionEngine;
+  private explainabilityLayer: ExplainabilityLayer;
+
+  constructor() {
+    this.constraintEngine = new ConstraintInferenceEngine();
+    this.spaceGenerator = new ArchitectureSpaceGenerator();
+    this.candidateGenerator = new ArchitectureCandidateGenerator();
+    this.tradeoffEngine = new TradeoffReasoningEngine();
+    this.simulationEngine = new FailureSimulationEngine();
+    this.decisionEngine = new DecisionEngine();
+    this.explainabilityLayer = new ExplainabilityLayer();
+  }
+
+  /**
+   * 推理架构
+   */
+  reason(context: {
+    domain?: string;
+    intent?: string;
+    scale?: string;
+    users?: number;
+    teamSize?: number;
+  }): ReasoningResult {
+    // Layer 1: Constraint Inference
+    const constraints = this.constraintEngine.infer(context);
+
+    // Layer 2: Architecture Space Definition
+    const space = this.spaceGenerator.generate(constraints);
+
+    // Layer 3: Candidate Generation
+    const candidates = this.candidateGenerator.generate(constraints, space);
+
+    // Layer 4: Trade-off Analysis
+    const tradeoffs = new Map<string, TradeoffAnalysis>();
+    for (const candidate of candidates) {
+      tradeoffs.set(candidate.type, this.tradeoffEngine.analyze(candidate));
+    }
+
+    // Layer 5: Failure Simulation
+    const simulations = new Map<string, FailureSimulation>();
+    for (const candidate of candidates) {
+      simulations.set(candidate.type, this.simulationEngine.simulate(candidate));
+    }
+
+    // Layer 6: Decision
+    const decision = this.decisionEngine.decide(candidates, tradeoffs, simulations);
+
+    // Layer 7: Explainability
+    const explanation = this.explainabilityLayer.explain(
+      decision,
+      tradeoffs.get(decision.selected),
+      simulations.get(decision.selected)
+    );
+
+    return {
+      constraints,
+      space,
+      candidates,
+      tradeoffs,
+      simulations,
+      decision,
+      explanation
+    };
+  }
+}
+
+// 导出所有类型
+export { Constraints } from "./ConstraintInferenceEngine";
+export { ArchitectureSpace } from "./ArchitectureSpaceGenerator";
+export { ArchitectureCandidate } from "./ArchitectureCandidateGenerator";
+export { TradeoffAnalysis } from "./TradeoffReasoningEngine";
+export { FailureSimulation } from "./FailureSimulationEngine";
+export { ArchitectureDecision } from "./DecisionEngine";
+export { ArchitectureExplanation } from "./ExplainabilityLayer";

package/src/review/ReviewConsensus.ts

@@ -0,0 +1,243 @@
+import { ReviewResult, Task, AgentAdapter } from "../types";
+
+/**
+ * ReviewConsensus
+ *
+ * Multi-reviewer consensus mechanism for v2.0.
+ * Supports three consensus strategies and three disagreement resolution methods.
+ */
+
+export interface ReviewConsensusConfig {
+  minReviewers: number;  // default 1
+  consensusStrategy: "unanimous" | "majority" | "best-score";
+  onDisagreement: "escalate" | "third-reviewer" | "highest-score";
+}
+
+export interface ReviewVote {
+  reviewerId: string;
+  result: ReviewResult;
+  timestamp: number;
+}
+
+export type ConsensusDecision = "PASS" | "FAIL" | "DISAGREEMENT";
+
+export interface ConsensusResult {
+  decision: ConsensusDecision;
+  finalDecision: "PASS" | "FAIL";  // resolved decision
+  votes: ReviewVote[];
+  strategy: string;
+  resolution?: string;  // how disagreement was resolved
+  score: number;  // aggregated score
+  issues: string[];  // aggregated issues
+}
+
+const DEFAULT_CONFIG: ReviewConsensusConfig = {
+  minReviewers: 1,
+  consensusStrategy: "majority",
+  onDisagreement: "highest-score",
+};
+
+export class ReviewConsensus {
+  private config: ReviewConsensusConfig;
+  private thirdPartyReviewer?: AgentAdapter;
+
+  constructor(config?: Partial<ReviewConsensusConfig>, thirdPartyReviewer?: AgentAdapter) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.thirdPartyReviewer = thirdPartyReviewer;
+  }
+
+  /**
+   * Collect reviews from multiple reviewers concurrently.
+   * Returns votes once minReviewers have responded.
+   */
+  async collectReviews(
+    task: Task,
+    reviewers: AgentAdapter[]
+  ): Promise<ReviewVote[]> {
+    if (reviewers.length < this.config.minReviewers) {
+      throw new Error(
+        `Need at least ${this.config.minReviewers} reviewers, got ${reviewers.length}`
+      );
+    }
+
+    const reviewPromises = reviewers.map(async (reviewer) => {
+      if (!reviewer.review) {
+        throw new Error(`${reviewer.name} has no review capability`);
+      }
+      const result = await reviewer.review(task);
+      return {
+        reviewerId: reviewer.name,
+        result,
+        timestamp: Date.now(),
+      } as ReviewVote;
+    });
+
+    // Wait for all reviewers
+    const votes = await Promise.all(reviewPromises);
+    return votes;
+  }
+
+  /**
+   * Resolve consensus from collected votes.
+   * Returns ConsensusResult with final decision.
+   */
+  resolve(votes: ReviewVote[]): ConsensusResult {
+    if (votes.length === 0) {
+      return {
+        decision: "FAIL",
+        finalDecision: "FAIL",
+        votes: [],
+        strategy: this.config.consensusStrategy,
+        resolution: "no-votes",
+        score: 0,
+        issues: ["No reviews collected"],
+      };
+    }
+
+    const passVotes = votes.filter((v) => v.result.decision === "PASS");
+    const failVotes = votes.filter((v) => v.result.decision === "FAIL");
+    const passRatio = passVotes.length / votes.length;
+
+    // Apply consensus strategy
+    let rawDecision: ConsensusDecision;
+    let resolution: string | undefined;
+
+    switch (this.config.consensusStrategy) {
+      case "unanimous":
+        rawDecision = passVotes.length === votes.length ? "PASS" : "FAIL";
+        break;
+
+      case "majority":
+        if (passRatio > 0.5) {
+          rawDecision = "PASS";
+        } else if (passRatio < 0.5) {
+          rawDecision = "FAIL";
+        } else {
+          rawDecision = "DISAGREEMENT";  // exact tie
+        }
+        break;
+
+      case "best-score":
+        const bestVote = [...votes].sort(
+          (a, b) => b.result.score - a.result.score
+        )[0];
+        rawDecision = bestVote.result.score >= 60 ? "PASS" : "FAIL";
+        resolution = `best-score: ${bestVote.result.score} from ${bestVote.reviewerId}`;
+        break;
+
+      default:
+        rawDecision = "FAIL";
+    }
+
+    // For majority/unanimous: if strategy already gave a clear answer, use it directly
+    // Only use disagreement resolution when strategy says DISAGREEMENT
+    let finalDecision: "PASS" | "FAIL";
+    if (rawDecision === "DISAGREEMENT") {
+      // Strategy couldn't decide — use disagreement resolution
+      const resolved = this.resolveDisagreement(votes, passVotes, failVotes);
+      finalDecision = resolved.decision;
+      resolution = resolved.resolution;
+    } else {
+      // Strategy gave a clear answer (PASS or FAIL) — honor it
+      finalDecision = rawDecision === "PASS" ? "PASS" : "FAIL";
+    }
+
+    // Aggregate score and issues
+    const avgScore =
+      votes.reduce((sum, v) => sum + v.result.score, 0) / votes.length;
+    const allIssues = [
+      ...new Set(votes.flatMap((v) => v.result.issues)),
+    ];
+
+    return {
+      decision: rawDecision,
+      finalDecision,
+      votes,
+      strategy: this.config.consensusStrategy,
+      resolution,
+      score: Math.round(avgScore),
+      issues: allIssues,
+    };
+  }
+
+  /**
+   * Resolve a disagreement based on onDisagreement config.
+   */
+  private resolveDisagreement(
+    votes: ReviewVote[],
+    passVotes: ReviewVote[],
+    failVotes: ReviewVote[]
+  ): { decision: "PASS" | "FAIL"; resolution: string } {
+    switch (this.config.onDisagreement) {
+      case "highest-score": {
+        const bestVote = [...votes].sort(
+          (a, b) => b.result.score - a.result.score
+        )[0];
+        return {
+          decision: bestVote.result.decision,
+          resolution: `highest-score: ${bestVote.result.score} from ${bestVote.reviewerId}`,
+        };
+      }
+
+      case "third-reviewer": {
+        if (this.thirdPartyReviewer?.review) {
+          // Note: third-party review is async, but resolve is sync.
+          // For sync resolution, fall back to highest-score.
+          // Real third-party review should be done via collectReviews with an extra reviewer.
+          const bestVote = [...votes].sort(
+            (a, b) => b.result.score - a.result.score
+          )[0];
+          return {
+            decision: bestVote.result.decision,
+            resolution: `third-reviewer-fallback (highest-score): ${bestVote.result.score} from ${bestVote.reviewerId}`,
+          };
+        }
+        // No third-party available, fall back to highest-score
+        const best = [...votes].sort(
+          (a, b) => b.result.score - a.result.score
+        )[0];
+        return {
+          decision: best.result.decision,
+          resolution: `no-third-reviewer (highest-score): ${best.result.score} from ${best.reviewerId}`,
+        };
+      }
+
+      case "escalate": {
+        // Signal escalation - caller should handle
+        const bestVote = [...votes].sort(
+          (a, b) => b.result.score - a.result.score
+        )[0];
+        return {
+          decision: bestVote.result.decision,
+          resolution: `escalated (highest-score used): ${bestVote.result.score} from ${bestVote.reviewerId}`,
+        };
+      }
+
+      default: {
+        // Default: fail on disagreement
+        return {
+          decision: "FAIL",
+          resolution: "disagreement-default: FAIL",
+        };
+      }
+    }
+  }
+
+  /**
+   * Convenience: collect reviews and resolve in one call.
+   */
+  async review(
+    task: Task,
+    reviewers: AgentAdapter[]
+  ): Promise<ConsensusResult> {
+    const votes = await this.collectReviews(task, reviewers);
+    return this.resolve(votes);
+  }
+
+  /**
+   * Get current config.
+   */
+  getConfig(): ReviewConsensusConfig {
+    return { ...this.config };
+  }
+}

package/src/runtime/CapabilityDiscovery.ts

@@ -0,0 +1,142 @@
+import { AgentAdapter, AgentProfile } from "../types";
+import { extractJson } from "../utils/OutputNormalizer";
+import * as fs from "fs";
+import * as path from "path";
+
+const CAPABILITIES_FILE = path.resolve(process.cwd(), ".agent-hive/runtime-capabilities.json");
+
+const PROBE_PROMPT = `List your capabilities as JSON. Return ONLY this JSON format:
+
+{
+  "capabilities": ["capability1", "capability2"]
+}
+
+Valid capabilities: coding, review, planning, research, refactor, architecture, security-scan, testing, documentation, debugging`;
+
+export interface CapabilityReport {
+  runtimeId: string;
+  capabilities: string[];
+  confidence: number;
+  source: "static" | "probe" | "merged";
+  timestamp: number;
+}
+
+export class CapabilityDiscovery {
+  private reports: Map<string, CapabilityReport> = new Map();
+
+  constructor() {
+    this.loadPersisted();
+  }
+
+  /**
+   * Discover capabilities for a runtime adapter.
+   *
+   * Step 1: Read adapter's static capabilities
+   * Step 2: Send probe prompt to runtime
+   * Step 3: Merge and persist
+   */
+  async discover(adapter: AgentAdapter): Promise<CapabilityReport> {
+    const staticCaps = adapter.capabilities || [];
+    let probeCaps: string[] = [];
+    let confidence = 0.5;
+
+    // Step 2: Probe the runtime
+    try {
+      const response = await this.probe(adapter);
+      if (response.length > 0) {
+        probeCaps = response;
+        confidence = 0.9;
+      }
+    } catch (e) {
+      // Probe failed, fall back to static only
+      console.debug("[CapabilityDiscovery] Probe failed, using static fallback:", e instanceof Error ? e.message : e);
+      confidence = 0.3;
+    }
+
+    // Step 3: Merge (union of static + probe)
+    const merged = [...new Set([...staticCaps, ...probeCaps])];
+
+    const report: CapabilityReport = {
+      runtimeId: adapter.name,
+      capabilities: merged,
+      confidence,
+      source: probeCaps.length > 0 ? "merged" : "static",
+      timestamp: Date.now(),
+    };
+
+    this.reports.set(adapter.name, report);
+    this.persist();
+
+    return report;
+  }
+
+  /**
+   * Get cached capability report for a runtime.
+   */
+  get(runtimeId: string): CapabilityReport | undefined {
+    return this.reports.get(runtimeId);
+  }
+
+  /**
+   * Get all reports.
+   */
+  all(): CapabilityReport[] {
+    return Array.from(this.reports.values());
+  }
+
+  /**
+   * Find runtimes that have a specific capability.
+   */
+  findByCapability(capability: string): CapabilityReport[] {
+    return this.all().filter(r => r.capabilities.includes(capability));
+  }
+
+  /**
+   * Send probe prompt to runtime and parse response.
+   */
+  private async probe(adapter: AgentAdapter): Promise<string[]> {
+    if (!adapter.execute) return [];
+
+    const result = await adapter.execute({
+      id: "probe",
+      instruction: PROBE_PROMPT,
+      executor: adapter.name,
+      reviewer: "",
+      status: "PENDING",
+      revisionCount: 0,
+      maxRevision: 1,
+      timeout: 30_000,
+      workingDirectory: process.cwd(),
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    if (!result.success || !result.output) return [];
+
+    const parsed = extractJson(result.output);
+    if (parsed && Array.isArray(parsed.capabilities)) {
+      return parsed.capabilities.filter((c: any) => typeof c === "string");
+    }
+
+    return [];
+  }
+
+  private persist(): void {
+    const data: Record<string, CapabilityReport> = {};
+    for (const [k, v] of this.reports) data[k] = v;
+    fs.mkdirSync(path.dirname(CAPABILITIES_FILE), { recursive: true });
+    fs.writeFileSync(CAPABILITIES_FILE, JSON.stringify(data, null, 2));
+  }
+
+  private loadPersisted(): void {
+    if (!fs.existsSync(CAPABILITIES_FILE)) return;
+    try {
+      const data = JSON.parse(fs.readFileSync(CAPABILITIES_FILE, "utf-8"));
+      for (const [k, v] of Object.entries(data)) {
+        this.reports.set(k, v as CapabilityReport);
+      }
+    } catch (e) {
+      console.warn("[CapabilityDiscovery] Failed to load persisted capabilities:", e instanceof Error ? e.message : e);
+    }
+  }
+}

package/src/runtime/EventBus.ts

@@ -0,0 +1,84 @@
+/**
+ * EventBus — append-only, immutable event store.
+ * Event sourcing compatible. Supports publish/subscribe/replay.
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+export interface Event {
+  id: string;
+  traceId: string;
+  timestamp: number;
+  type: string;
+  payload: unknown;
+}
+
+export class EventBus {
+  private events: Event[] = [];
+  private subscribers: Map<string, ((event: Event) => void)[]> = new Map();
+  private logDir: string;
+
+  constructor(logDir?: string) {
+    this.logDir = logDir || path.resolve(process.cwd(), ".agent-hive/events");
+    fs.mkdirSync(this.logDir, { recursive: true });
+  }
+
+  /** Publish an event (append-only, immutable) */
+  publish(event: Event): void {
+    this.events.push(event);
+
+    // Persist to file
+    const logFile = path.join(this.logDir, `${event.traceId}.jsonl`);
+    fs.appendFileSync(logFile, JSON.stringify(event) + "\n");
+
+    // Notify subscribers
+    const handlers = this.subscribers.get(event.type) || [];
+    for (const handler of handlers) {
+      handler(event);
+    }
+
+    // Also notify wildcard subscribers
+    const wildcardHandlers = this.subscribers.get("*") || [];
+    for (const handler of wildcardHandlers) {
+      handler(event);
+    }
+  }
+
+  /** Subscribe to events by type */
+  subscribe(eventType: string, handler: (event: Event) => void): void {
+    if (!this.subscribers.has(eventType)) {
+      this.subscribers.set(eventType, []);
+    }
+    this.subscribers.get(eventType)!.push(handler);
+  }
+
+  /** Replay all events for a trace */
+  replay(traceId: string): Event[] {
+    // Try memory first, then file
+    const memEvents = this.events.filter(e => e.traceId === traceId);
+    if (memEvents.length > 0) return memEvents;
+
+    const logFile = path.join(this.logDir, `${traceId}.jsonl`);
+    if (!fs.existsSync(logFile)) return [];
+
+    return fs.readFileSync(logFile, "utf-8")
+      .split("\n")
+      .filter(l => l.trim())
+      .map(l => JSON.parse(l));
+  }
+
+  /** Get all events */
+  all(): Event[] {
+    return [...this.events];
+  }
+
+  /** Get events by type */
+  byType(type: string): Event[] {
+    return this.events.filter(e => e.type === type);
+  }
+
+  /** Generate a unique event ID */
+  static generateId(): string {
+    return `evt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  }
+}