@toyako/hive 1.0.0

package/src/orchestration/JudgeAgent.ts

@@ -0,0 +1,69 @@
+/**
+ * JudgeAgent — final acceptance authority.
+ * Reviewer Pass ≠ Judge Pass. Judge has final say.
+ */
+import { Agent, Task, TaskResult, ReviewResult, JudgeResult } from "./contracts/Agent";
+import { AgentProfile } from "./registry/AgentProfile";
+
+export class JudgeAgent implements Agent {
+  profile: AgentProfile = {
+    id: "judge",
+    name: "Judge",
+    role: "judge",
+    capabilities: ["acceptance", "scoring"],
+    priority: 100,
+    enabled: true,
+  };
+
+  canHandle(task: Task): boolean {
+    return task.type === "acceptance" || task.type === "scoring";
+  }
+
+  async execute(task: Task): Promise<TaskResult> {
+    return {
+      taskId: task.id,
+      agentId: this.profile.id,
+      success: true,
+      output: "Judgment completed",
+      durationMs: 0,
+    };
+  }
+
+  /** Judge accepts or rejects based on task result + review */
+  judge(result: TaskResult, review: ReviewResult): JudgeResult {
+    let score = review.score;
+    const reasons: string[] = [];
+
+    // Judge criteria
+    if (!result.success) {
+      score = 0;
+      reasons.push("Task execution failed");
+    }
+
+    if (!review.approved) {
+      score = Math.min(score, 40);
+      reasons.push("Reviewer did not approve");
+    }
+
+    if (review.findings.length > 3) {
+      score -= 10;
+      reasons.push("Too many findings from reviewer");
+    }
+
+    if (result.output.length > 100) {
+      score += 5;
+      reasons.push("Substantial output produced");
+    }
+
+    const finalScore = Math.max(0, Math.min(100, score));
+    const accepted = finalScore >= 70;
+
+    return {
+      taskId: result.taskId,
+      judgeId: this.profile.id,
+      accepted,
+      score: finalScore,
+      reason: reasons.length > 0 ? reasons.join("; ") : (accepted ? "All criteria met" : "Score below threshold"),
+    };
+  }
+}

package/src/orchestration/Planner.ts

@@ -0,0 +1,52 @@
+/**
+ * Planner — decomposes user requests into Task DAGs.
+ */
+import { Task } from "./contracts/Agent";
+
+export class Planner {
+  /** Plan a task DAG from a user request */
+  plan(request: string): Task[] {
+    // Analyze request and create task decomposition
+    const taskId = `task-${Date.now().toString(36)}`;
+
+    // Simple heuristic: if request mentions multiple things, split
+    const tasks = this.decompose(request, taskId);
+
+    return tasks;
+  }
+
+  private decompose(request: string, baseId: string): Task[] {
+    const lower = request.toLowerCase();
+
+    // Pattern: design + implement + test + review
+    if (lower.includes("build") || lower.includes("create") || lower.includes("implement")) {
+      return [
+        { id: `${baseId}-design`, title: "Design", description: `Design architecture for: ${request}`, type: "planning", priority: 1, dependencies: [] },
+        { id: `${baseId}-implement`, title: "Implement", description: `Implement: ${request}`, type: "coding", priority: 2, dependencies: [`${baseId}-design`] },
+        { id: `${baseId}-test`, title: "Test", description: `Test implementation of: ${request}`, type: "testing", priority: 3, dependencies: [`${baseId}-implement`] },
+        { id: `${baseId}-review`, title: "Review", description: `Review: ${request}`, type: "review", priority: 4, dependencies: [`${baseId}-test`] },
+      ];
+    }
+
+    // Pattern: refactor
+    if (lower.includes("refactor") || lower.includes("improve") || lower.includes("optimize")) {
+      return [
+        { id: `${baseId}-analyze`, title: "Analyze", description: `Analyze code for: ${request}`, type: "analysis", priority: 1, dependencies: [] },
+        { id: `${baseId}-refactor`, title: "Refactor", description: `Refactor: ${request}`, type: "coding", priority: 2, dependencies: [`${baseId}-analyze`] },
+        { id: `${baseId}-review`, title: "Review", description: `Review refactoring: ${request}`, type: "review", priority: 3, dependencies: [`${baseId}-refactor`] },
+      ];
+    }
+
+    // Pattern: review only
+    if (lower.includes("review") || lower.includes("audit")) {
+      return [
+        { id: `${baseId}-review`, title: "Review", description: `Review: ${request}`, type: "review", priority: 1, dependencies: [] },
+      ];
+    }
+
+    // Default: single task
+    return [
+      { id: baseId, title: "Execute", description: request, type: "general", priority: 1, dependencies: [] },
+    ];
+  }
+}

package/src/orchestration/ReviewerAgent.ts

@@ -0,0 +1,76 @@
+/**
+ * ReviewerAgent — reviews all agent outputs.
+ */
+import { Agent, Task, TaskResult, ReviewResult } from "./contracts/Agent";
+import { AgentProfile } from "./registry/AgentProfile";
+
+export class ReviewerAgent implements Agent {
+  profile: AgentProfile = {
+    id: "reviewer",
+    name: "Reviewer",
+    role: "reviewer",
+    capabilities: ["audit", "verification", "quality"],
+    priority: 10,
+    enabled: true,
+  };
+
+  canHandle(task: Task): boolean {
+    return task.type === "review" || task.type === "audit";
+  }
+
+  async execute(task: Task): Promise<TaskResult> {
+    return {
+      taskId: task.id,
+      agentId: this.profile.id,
+      success: true,
+      output: "Review completed",
+      durationMs: 0,
+    };
+  }
+
+  async review(result: TaskResult): Promise<ReviewResult> {
+    const findings: string[] = [];
+    let score = 100;
+
+    // P0: Task execution failed
+    if (!result.success) {
+      findings.push("Task execution failed");
+      score -= 50;
+    }
+
+    // P1: Output quality checks (Finding #1 fix)
+    if (!result.output || result.output.trim().length === 0) {
+      findings.push("Empty output — no deliverable produced");
+      score -= 80; // Almost certainly a failure
+    } else if (result.output.trim().length < 10) {
+      findings.push("Output too short — insufficient deliverable");
+      score -= 60; // Very likely a failure
+    }
+
+    // P2: Negative keyword detection (Finding #2 fix)
+    const negativeKeywords = ["warning", "TODO", "FIXME", "no tests", "partial", "incomplete", "not implemented", "stub"];
+    const outputLower = (result.output || "").toLowerCase();
+    for (const keyword of negativeKeywords) {
+      if (outputLower.includes(keyword.toLowerCase())) {
+        findings.push(`Negative indicator found: "${keyword}"`);
+        score -= 15;
+      }
+    }
+
+    // P3: Execution time
+    if (result.durationMs > 60000) {
+      findings.push("Execution took over 60 seconds");
+      score -= 10;
+    }
+
+    const finalScore = Math.max(0, Math.min(100, score));
+
+    return {
+      taskId: result.taskId,
+      reviewerId: this.profile.id,
+      score: finalScore,
+      findings,
+      approved: finalScore >= 60,
+    };
+  }
+}

package/src/orchestration/contracts/Agent.ts

@@ -0,0 +1,46 @@
+/**
+ * Agent — unified agent contract.
+ */
+import { AgentProfile } from "../registry/AgentProfile";
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  type: string;
+  priority: number;
+  dependencies: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface TaskResult {
+  taskId: string;
+  agentId: string;
+  success: boolean;
+  output: string;
+  durationMs: number;
+  artifacts?: string[];
+}
+
+export interface ReviewResult {
+  taskId: string;
+  reviewerId: string;
+  score: number;
+  findings: string[];
+  approved: boolean;
+}
+
+export interface JudgeResult {
+  taskId: string;
+  judgeId: string;
+  accepted: boolean;
+  score: number;
+  reason: string;
+}
+
+export interface Agent {
+  profile: AgentProfile;
+  canHandle(task: Task): boolean;
+  execute(task: Task): Promise<TaskResult>;
+  review?(result: TaskResult): Promise<ReviewResult>;
+}

package/src/orchestration/registry/AgentProfile.ts

@@ -0,0 +1,11 @@
+/**
+ * AgentProfile — agent registration profile.
+ */
+export interface AgentProfile {
+  id: string;
+  name: string;
+  role: string;
+  capabilities: string[];
+  priority: number;
+  enabled: boolean;
+}

package/src/orchestration/registry/AgentRegistry.ts

@@ -0,0 +1,36 @@
+/**
+ * AgentRegistry — manages registered agents.
+ */
+import { AgentProfile } from "./AgentProfile";
+
+export class AgentRegistry {
+  private agents: Map<string, AgentProfile> = new Map();
+
+  register(agent: AgentProfile): void {
+    this.agents.set(agent.id, agent);
+  }
+
+  unregister(id: string): boolean {
+    return this.agents.delete(id);
+  }
+
+  list(): AgentProfile[] {
+    return Array.from(this.agents.values());
+  }
+
+  get(id: string): AgentProfile | null {
+    return this.agents.get(id) || null;
+  }
+
+  findByCapability(capability: string): AgentProfile[] {
+    return this.list().filter(a => a.enabled && a.capabilities.includes(capability));
+  }
+
+  findByRole(role: string): AgentProfile[] {
+    return this.list().filter(a => a.enabled && a.role === role);
+  }
+
+  enabled(): AgentProfile[] {
+    return this.list().filter(a => a.enabled);
+  }
+}

package/src/planning/ProjectPlanningLayer.ts

@@ -0,0 +1,230 @@
+/**
+ * Project Planning Layer
+ * 
+ * Transform architecture into executable engineering plans.
+ * 
+ * Output:
+ * - Milestones
+ * - Sprint Plans
+ * - Dependency Graph
+ * - Risk Analysis
+ * - Execution Blueprint
+ * 
+ * Runtime must execute plans. Planning occurs before Runtime.
+ */
+
+import { ProductSpecification } from "../product/ProductEngineeringLayer";
+import { Architecture } from "../compiler/ArchitectureSynthesizer";
+
+// Sprint
+export interface Sprint {
+  id: string;
+  milestone: string;
+  objectives: string[];
+  tasks: string[];
+  dependencies: string[];
+  deliverables: string[];
+  acceptanceCriteria: string[];
+  complexity: "low" | "medium" | "high";
+}
+
+// Milestone
+export interface Milestone {
+  id: string;
+  name: string;
+  sprints: Sprint[];
+  deliverables: string[];
+  dependencies: string[];
+}
+
+// Risk
+export interface Risk {
+  type: "technical" | "architecture" | "dependency" | "schedule";
+  description: string;
+  severity: "low" | "medium" | "high";
+  mitigation: string;
+}
+
+// Project Plan
+export interface ProjectPlan {
+  milestones: Milestone[];
+  dependencyGraph: Record<string, string[]>;
+  risks: Risk[];
+  executionConstraints: string[];
+}
+
+export class ProjectPlanningLayer {
+  /**
+   * 生成项目计划
+   */
+  plan(spec: ProductSpecification, architecture: Architecture): ProjectPlan {
+    const milestones = this.generateMilestones(spec);
+    const dependencyGraph = this.generateDependencyGraph(milestones);
+    const risks = this.identifyRisks(spec, architecture);
+    const executionConstraints = this.defineConstraints(spec);
+
+    return {
+      milestones,
+      dependencyGraph,
+      risks,
+      executionConstraints
+    };
+  }
+
+  /**
+   * 生成里程碑
+   */
+  private generateMilestones(spec: ProductSpecification): Milestone[] {
+    const milestones: Milestone[] = [];
+    let sprintId = 1;
+
+    // Milestone 1: Core Infrastructure
+    const m1Sprints: Sprint[] = [];
+    m1Sprints.push({
+      id: `S${sprintId++}`,
+      milestone: "M1",
+      objectives: ["Setup project structure", "Configure database"],
+      tasks: ["Initialize project", "Setup ORM", "Create migrations"],
+      dependencies: [],
+      deliverables: ["Project skeleton", "Database schema"],
+      acceptanceCriteria: ["Project builds", "Database connects"],
+      complexity: "low"
+    });
+    m1Sprints.push({
+      id: `S${sprintId++}`,
+      milestone: "M1",
+      objectives: ["Implement authentication"],
+      tasks: ["Create User model", "Implement JWT", "Create auth endpoints"],
+      dependencies: [`S${sprintId - 2}`],
+      deliverables: ["Auth module", "Login/Register API"],
+      acceptanceCriteria: ["User can login", "Token is valid"],
+      complexity: "medium"
+    });
+    milestones.push({
+      id: "M1",
+      name: "Core Infrastructure",
+      sprints: m1Sprints,
+      deliverables: ["Project skeleton", "Database", "Authentication"],
+      dependencies: []
+    });
+
+    // Milestone 2: Core Features
+    const m2Sprints: Sprint[] = [];
+    const requiredFeatures = spec.features.filter(f => f.priority === "required");
+    for (const feature of requiredFeatures.slice(0, 3)) {
+      m2Sprints.push({
+        id: `S${sprintId++}`,
+        milestone: "M2",
+        objectives: [`Implement ${feature.name}`],
+        tasks: feature.acceptanceCriteria.map(c => `Implement: ${c}`),
+        dependencies: ["M1"],
+        deliverables: [`${feature.name} module`],
+        acceptanceCriteria: feature.acceptanceCriteria,
+        complexity: "medium"
+      });
+    }
+    milestones.push({
+      id: "M2",
+      name: "Core Features",
+      sprints: m2Sprints,
+      deliverables: requiredFeatures.slice(0, 3).map(f => f.name),
+      dependencies: ["M1"]
+    });
+
+    // Milestone 3: Additional Features
+    const m3Sprints: Sprint[] = [];
+    const recommendedFeatures = spec.features.filter(f => f.priority === "recommended");
+    for (const feature of recommendedFeatures.slice(0, 2)) {
+      m3Sprints.push({
+        id: `S${sprintId++}`,
+        milestone: "M3",
+        objectives: [`Implement ${feature.name}`],
+        tasks: feature.acceptanceCriteria.map(c => `Implement: ${c}`),
+        dependencies: ["M2"],
+        deliverables: [`${feature.name} module`],
+        acceptanceCriteria: feature.acceptanceCriteria,
+        complexity: "medium"
+      });
+    }
+    milestones.push({
+      id: "M3",
+      name: "Additional Features",
+      sprints: m3Sprints,
+      deliverables: recommendedFeatures.slice(0, 2).map(f => f.name),
+      dependencies: ["M2"]
+    });
+
+    return milestones;
+  }
+
+  /**
+   * 生成依赖图
+   */
+  private generateDependencyGraph(milestones: Milestone[]): Record<string, string[]> {
+    const graph: Record<string, string[]> = {};
+
+    for (const milestone of milestones) {
+      graph[milestone.id] = milestone.dependencies;
+
+      for (const sprint of milestone.sprints) {
+        graph[sprint.id] = sprint.dependencies;
+      }
+    }
+
+    return graph;
+  }
+
+  /**
+   * 识别风险
+   */
+  private identifyRisks(spec: ProductSpecification, architecture: Architecture): Risk[] {
+    const risks: Risk[] = [];
+
+    // 技术风险
+    if (architecture.architectureStyle === "microservice") {
+      risks.push({
+        type: "architecture",
+        description: "Microservices complexity",
+        severity: "high",
+        mitigation: "Start with modular monolith, refactor later"
+      });
+    }
+
+    // 依赖风险
+    if (spec.modules.length > 10) {
+      risks.push({
+        type: "dependency",
+        description: "Too many modules",
+        severity: "medium",
+        mitigation: "Prioritize core modules first"
+      });
+    }
+
+    // 进度风险
+    const requiredFeatures = spec.features.filter(f => f.priority === "required");
+    if (requiredFeatures.length > 5) {
+      risks.push({
+        type: "schedule",
+        description: "Too many required features",
+        severity: "medium",
+        mitigation: "Phase delivery across multiple releases"
+      });
+    }
+
+    return risks;
+  }
+
+  /**
+   * 定义约束
+   */
+  private defineConstraints(spec: ProductSpecification): string[] {
+    const constraints: string[] = [];
+
+    constraints.push("Each sprint must produce executable software");
+    constraints.push("Each sprint must produce reviewable output");
+    constraints.push("Each sprint must support rollback");
+    constraints.push("Runtime must never receive raw user intent");
+
+    return constraints;
+  }
+}

package/src/platform/PlatformCapabilities.ts

@@ -0,0 +1,42 @@
+/**
+ * PlatformCapabilities — declarative platform capability description.
+ * No if (platform === ...) checks. All behavior driven by capabilities.
+ */
+import * as os from "os";
+
+export interface PlatformCapabilities {
+  shell: "cmd" | "bash" | "pwsh";
+  supportsPipe: boolean;
+  supportsSequence: boolean;
+  pathStyle: "windows" | "unix";
+  encoding: "utf-8";
+  lineEnding: "\r\n" | "\n";
+  envSeparator: ";" | ":";
+}
+
+/** Detect current platform capabilities */
+export function detectCapabilities(): PlatformCapabilities {
+  const isWindows = os.platform() === "win32";
+
+  if (isWindows) {
+    return {
+      shell: "cmd",
+      supportsPipe: true,
+      supportsSequence: true,
+      pathStyle: "windows",
+      encoding: "utf-8",
+      lineEnding: "\r\n",
+      envSeparator: ";",
+    };
+  }
+
+  return {
+    shell: "bash",
+    supportsPipe: true,
+    supportsSequence: true,
+    pathStyle: "unix",
+    encoding: "utf-8",
+    lineEnding: "\n",
+    envSeparator: ":",
+  };
+}

package/src/platform/auth/AuthService.ts

@@ -0,0 +1,50 @@
+/**
+ * AuthService — Platform Phase 1
+ * 
+ * 支持：
+ * - API Key
+ * - 未来可扩展：JWT, OAuth2, OIDC
+ */
+
+// Auth Result
+export interface AuthResult {
+  valid: boolean;
+  userId?: string;
+  error?: string;
+}
+
+export class AuthService {
+  private apiKeys: Map<string, string> = new Map(); // apiKey -> userId
+
+  /**
+   * 注册 API Key
+   */
+  registerApiKey(apiKey: string, userId: string): void {
+    this.apiKeys.set(apiKey, userId);
+  }
+
+  /**
+   * 验证 API Key
+   */
+  validateApiKey(apiKey: string): AuthResult {
+    const userId = this.apiKeys.get(apiKey);
+    if (userId) {
+      return { valid: true, userId };
+    }
+    return { valid: false, error: "Invalid API Key" };
+  }
+
+  /**
+   * 删除 API Key
+   */
+  removeApiKey(apiKey: string): boolean {
+    return this.apiKeys.delete(apiKey);
+  }
+
+  /**
+   * 获取所有 API Keys
+   */
+  getApiKeys(): string[] {
+    return Array.from(this.apiKeys.keys());
+  }
+}

package/src/platform/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Platform — Platform Phase 1
+ * 
+ * Runtime 不再是产品，Platform 才是产品
+ */
+
+import { ApiServer } from "./server/ApiServer";
+import { AuthService } from "./auth/AuthService";
+import { AgentHive } from "./sdk";
+import { MetricsService } from "./services/MetricsService";
+import { ProductionRuntime } from "../production/ProductionRuntime";
+
+export class Platform {
+  private apiServer: ApiServer;
+  private authService: AuthService;
+  private metricsService: MetricsService;
+  private runtime: ProductionRuntime;
+
+  constructor(port: number = 3000) {
+    this.runtime = new ProductionRuntime();
+    this.apiServer = new ApiServer(this.runtime, port);
+    this.authService = new AuthService();
+    this.metricsService = new MetricsService();
+  }
+
+  /**
+   * 启动平台
+   */
+  async start(): Promise<void> {
+    await this.apiServer.start();
+    console.log("[Platform] Started");
+  }
+
+  /**
+   * 停止平台
+   */
+  async stop(): Promise<void> {
+    await this.apiServer.stop();
+    console.log("[Platform] Stopped");
+  }
+
+  /**
+   * 获取 API Server
+   */
+  getApiServer(): ApiServer {
+    return this.apiServer;
+  }
+
+  /**
+   * 获取 Auth Service
+   */
+  getAuthService(): AuthService {
+    return this.authService;
+  }
+
+  /**
+   * 获取 Metrics Service
+   */
+  getMetricsService(): MetricsService {
+    return this.metricsService;
+  }
+
+  /**
+   * 获取 Runtime
+   */
+  getRuntime(): ProductionRuntime {
+    return this.runtime;
+  }
+}
+
+// 导出 SDK
+export { AgentHive } from "./sdk";
+export type { AgentHiveConfig, ExecutionResult } from "./sdk";