@toyako/hive 1.0.0

package/src/compiler/InputNormalizer.ts

@@ -0,0 +1,88 @@
+/**
+ * Input Normalization Layer — Intent Compiler Layer 0
+ * 
+ * 统一用户输入结构
+ */
+
+// Normalized Intent
+export interface NormalizedIntent {
+  rawIntent: string;
+  intentType: "app" | "api" | "workflow" | "tool";
+  complexity: "low" | "medium" | "high";
+  constraints?: {
+    techStack?: string[];
+    domain?: string;
+    scale?: string;
+  };
+}
+
+export class InputNormalizer {
+  /**
+   * 标准化用户输入
+   */
+  normalize(rawInput: string): NormalizedIntent {
+    const input = rawInput.toLowerCase().trim();
+
+    return {
+      rawIntent: rawInput,
+      intentType: this.detectIntentType(input),
+      complexity: this.detectComplexity(input),
+      constraints: this.extractConstraints(input)
+    };
+  }
+
+  /**
+   * 检测意图类型
+   */
+  private detectIntentType(input: string): NormalizedIntent["intentType"] {
+    if (input.includes("api") || input.includes("rest") || input.includes("graphql")) {
+      return "api";
+    }
+    if (input.includes("workflow") || input.includes("pipeline") || input.includes("process")) {
+      return "workflow";
+    }
+    if (input.includes("tool") || input.includes("cli") || input.includes("utility")) {
+      return "tool";
+    }
+    return "app";
+  }
+
+  /**
+   * 检测复杂度
+   */
+  private detectComplexity(input: string): NormalizedIntent["complexity"] {
+    const wordCount = input.split(/\s+/).length;
+    
+    if (wordCount > 20 || input.includes("complex") || input.includes("enterprise")) {
+      return "high";
+    }
+    if (wordCount > 10 || input.includes("multiple") || input.includes("integrate")) {
+      return "medium";
+    }
+    return "low";
+  }
+
+  /**
+   * 提取约束
+   */
+  private extractConstraints(input: string): NormalizedIntent["constraints"] {
+    const constraints: NormalizedIntent["constraints"] = {};
+
+    // 技术栈检测
+    const techStacks = ["react", "vue", "angular", "node", "python", "go", "rust"];
+    constraints.techStack = techStacks.filter(tech => input.includes(tech));
+
+    // 领域检测
+    const domains = ["ecommerce", "social", "finance", "healthcare", "education"];
+    constraints.domain = domains.find(d => input.includes(d));
+
+    // 规模检测
+    if (input.includes("enterprise") || input.includes("large")) {
+      constraints.scale = "large";
+    } else if (input.includes("small") || input.includes("personal")) {
+      constraints.scale = "small";
+    }
+
+    return constraints;
+  }
+}

package/src/compiler/IntentParser.ts

@@ -0,0 +1,109 @@
+/**
+ * Intent Parser — Intent Compiler Layer 1
+ * 
+ * 解析用户意图
+ * 
+ * 输出：
+ * - product intent
+ * - implicit requirements
+ * - domain guess
+ */
+
+import { NormalizedIntent } from "./InputNormalizer";
+
+// Parsed Intent
+export interface ParsedIntent {
+  productIntent: string;
+  implicitRequirements: string[];
+  domain: string;
+  features: string[];
+}
+
+export class IntentParser {
+  /**
+   * 解析意图
+   */
+  parse(intent: NormalizedIntent): ParsedIntent {
+    const input = intent.rawIntent.toLowerCase();
+
+    return {
+      productIntent: this.extractProductIntent(intent.rawIntent),
+      implicitRequirements: this.extractImplicitRequirements(input),
+      domain: intent.constraints?.domain || this.guessDomain(input),
+      features: this.extractFeatures(input)
+    };
+  }
+
+  /**
+   * 提取产品意图
+   */
+  private extractProductIntent(raw: string): string {
+    // 提取核心动词 + 宾语
+    const patterns = [
+      /build\s+(?:a\s+)?(.+)/i,
+      /create\s+(?:a\s+)?(.+)/i,
+      /make\s+(?:a\s+)?(.+)/i,
+      /develop\s+(?:a\s+)?(.+)/i
+    ];
+
+    for (const pattern of patterns) {
+      const match = raw.match(pattern);
+      if (match) return match[1].trim();
+    }
+
+    return raw;
+  }
+
+  /**
+   * 提取隐式需求
+   */
+  private extractImplicitRequirements(input: string): string[] {
+    const requirements: string[] = [];
+
+    if (input.includes("user") || input.includes("login") || input.includes("auth")) {
+      requirements.push("authentication");
+    }
+    if (input.includes("data") || input.includes("store") || input.includes("save")) {
+      requirements.push("database");
+    }
+    if (input.includes("api") || input.includes("rest") || input.includes("endpoint")) {
+      requirements.push("api_layer");
+    }
+    if (input.includes("deploy") || input.includes("production") || input.includes("scale")) {
+      requirements.push("deployment");
+    }
+
+    return requirements;
+  }
+
+  /**
+   * 猜测领域
+   */
+  private guessDomain(input: string): string {
+    if (input.includes("shop") || input.includes("store") || input.includes("ecommerce")) return "ecommerce";
+    if (input.includes("social") || input.includes("chat") || input.includes("message")) return "social";
+    if (input.includes("blog") || input.includes("content") || input.includes("cms")) return "content";
+    if (input.includes("task") || input.includes("todo") || input.includes("project")) return "productivity";
+    return "general";
+  }
+
+  /**
+   * 提取功能
+   */
+  private extractFeatures(input: string): string[] {
+    const features: string[] = [];
+    
+    const featurePatterns = [
+      "login", "register", "profile", "dashboard", "search",
+      "notification", "payment", "upload", "download", "chat"
+    ];
+
+    for (const feature of featurePatterns) {
+      if (input.includes(feature)) {
+        features.push(feature);
+      }
+    }
+
+    return features;
+  }
+}

package/src/compiler/ModulePlanner.ts

@@ -0,0 +1,32 @@
+/**
+ * Module Planner — Intent Compiler Layer 5
+ */
+
+import { DomainModel } from "./DomainModelGenerator";
+import { Architecture } from "./ArchitectureSynthesizer";
+
+export interface ModulePlan {
+  modules: string[];
+  dependencies: Record<string, string[]>;
+}
+
+export class ModulePlanner {
+  plan(domainModel: DomainModel, architecture: Architecture): ModulePlan {
+    const modules: string[] = [];
+    const dependencies: Record<string, string[]> = {};
+
+    // 根据实体生成模块
+    for (const entity of domainModel.entities) {
+      const moduleName = `${entity.name}Module`;
+      modules.push(moduleName);
+      dependencies[moduleName] = entity.relationships.map(r => `${r}Module`);
+    }
+
+    // 添加基础模块
+    modules.push("AuthModule", "DatabaseModule", "APIModule");
+    dependencies["AuthModule"] = ["DatabaseModule"];
+    dependencies["APIModule"] = ["AuthModule"];
+
+    return { modules, dependencies };
+  }
+}

package/src/compiler/PromptCompiler.ts

@@ -0,0 +1,39 @@
+/**
+ * Prompt Compiler — Intent Compiler Layer 7
+ */
+
+import { ExecutionDAG } from "./DAGCompiler";
+
+export interface NodePrompt {
+  nodeId: string;
+  role: "planner" | "developer" | "reviewer";
+  promptTemplate: string;
+  constraints: {
+    outputFormat: "code" | "json" | "text";
+    validationRules: string[];
+  };
+}
+
+export class PromptCompiler {
+  compile(dag: ExecutionDAG): NodePrompt[] {
+    return dag.nodes.map(nodeId => ({
+      nodeId,
+      role: this.assignRole(nodeId),
+      promptTemplate: this.generateTemplate(nodeId),
+      constraints: {
+        outputFormat: "code" as const,
+        validationRules: ["must be valid", "must be complete"]
+      }
+    }));
+  }
+
+  private assignRole(nodeId: string): NodePrompt["role"] {
+    if (nodeId.includes("Auth") || nodeId.includes("API")) return "developer";
+    if (nodeId.includes("Review")) return "reviewer";
+    return "planner";
+  }
+
+  private generateTemplate(nodeId: string): string {
+    return `Implement ${nodeId} following best practices.`;
+  }
+}

package/src/compiler/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Intent Compiler v1
+ * 
+ * Natural Language → Validated System Blueprint → Executable DAG → Agent Hive Runtime
+ * 
+ * 系统本质：Software Compiler for Natural Language
+ */
+
+import { InputNormalizer, NormalizedIntent } from "./InputNormalizer";
+import { IntentParser, ParsedIntent } from "./IntentParser";
+import { DomainModelGenerator, DomainModel } from "./DomainModelGenerator";
+import { ArchitectureSynthesizer, Architecture } from "./ArchitectureSynthesizer";
+import { FeasibilityGate, FeasibilityReport } from "./FeasibilityGate";
+import { ModulePlanner, ModulePlan } from "./ModulePlanner";
+import { DAGCompiler, ExecutionDAG } from "./DAGCompiler";
+import { PromptCompiler, NodePrompt } from "./PromptCompiler";
+import { BlueprintPackager, SystemPackage } from "./BlueprintPackager";
+
+export class IntentCompiler {
+  private normalizer: InputNormalizer;
+  private parser: IntentParser;
+  private domainGenerator: DomainModelGenerator;
+  private archSynthesizer: ArchitectureSynthesizer;
+  private feasibilityGate: FeasibilityGate;
+  private modulePlanner: ModulePlanner;
+  private dagCompiler: DAGCompiler;
+  private promptCompiler: PromptCompiler;
+  private packager: BlueprintPackager;
+
+  constructor() {
+    this.normalizer = new InputNormalizer();
+    this.parser = new IntentParser();
+    this.domainGenerator = new DomainModelGenerator();
+    this.archSynthesizer = new ArchitectureSynthesizer();
+    this.feasibilityGate = new FeasibilityGate();
+    this.modulePlanner = new ModulePlanner();
+    this.dagCompiler = new DAGCompiler();
+    this.promptCompiler = new PromptCompiler();
+    this.packager = new BlueprintPackager();
+  }
+
+  /**
+   * 编译用户输入为系统包
+   */
+  compile(userInput: string): SystemPackage {
+    // Layer 0: Input Normalization
+    const normalized = this.normalizer.normalize(userInput);
+
+    // Layer 1: Intent Parser
+    const parsed = this.parser.parse(normalized);
+
+    // Layer 2: Domain Model Generator
+    const domainModel = this.domainGenerator.generate(parsed);
+
+    // Layer 3: Architecture Synthesizer
+    const architecture = this.archSynthesizer.synthesize(normalized, parsed, domainModel);
+
+    // Layer 4: Feasibility Gate
+    const feasibility = this.feasibilityGate.check(architecture, domainModel, parsed);
+
+    // Layer 5: Module Planner
+    const modules = this.modulePlanner.plan(domainModel, architecture);
+
+    // Layer 6: DAG Compiler
+    const dag = this.dagCompiler.compile(modules);
+
+    // Layer 7: Prompt Compiler
+    const prompts = this.promptCompiler.compile(dag);
+
+    // Layer 8: Blueprint Packager
+    return this.packager.pack(architecture, domainModel, modules, dag, prompts, feasibility);
+  }
+}
+
+// 导出所有类型
+export { NormalizedIntent } from "./InputNormalizer";
+export { ParsedIntent } from "./IntentParser";
+export { DomainModel, Entity } from "./DomainModelGenerator";
+export { Architecture } from "./ArchitectureSynthesizer";
+export { FeasibilityReport } from "./FeasibilityGate";
+export { ModulePlan } from "./ModulePlanner";
+export { ExecutionDAG } from "./DAGCompiler";
+export { NodePrompt } from "./PromptCompiler";
+export { SystemPackage } from "./BlueprintPackager";

package/src/context/ContextManager.ts

@@ -0,0 +1,63 @@
+/**
+ * ContextManager — manages context scopes for sub-agents.
+ * Each agent gets isolated context, communicates via summaries only.
+ */
+
+export interface ContextScope {
+  agentId: string;
+  taskSummary: string;
+  relevantFiles: string[];
+  constraints: string[];
+}
+
+export class ContextManager {
+  private scopes: Map<string, ContextScope> = new Map();
+
+  /** Create an isolated scope for an agent */
+  createScope(agentId: string, taskSummary: string, relevantFiles: string[] = [], constraints: string[] = []): void {
+    this.scopes.set(agentId, { agentId, taskSummary, relevantFiles, constraints });
+  }
+
+  /** Get an agent's scope */
+  getScope(agentId: string): ContextScope | null {
+    return this.scopes.get(agentId) || null;
+  }
+
+  /** Build a context prompt for an agent (isolated — no raw conversation) */
+  buildContextPrompt(agentId: string, task: string): string {
+    const scope = this.scopes.get(agentId);
+    if (!scope) return task;
+
+    const parts = [task, ""];
+
+    if (scope.taskSummary) {
+      parts.push(`## Summary\n${scope.taskSummary}`);
+    }
+
+    if (scope.relevantFiles.length > 0) {
+      parts.push(`## Relevant Files\n${scope.relevantFiles.join("\n")}`);
+    }
+
+    if (scope.constraints.length > 0) {
+      parts.push(`## Constraints\n${scope.constraints.map(c => `- ${c}`).join("\n")}`);
+    }
+
+    return parts.join("\n");
+  }
+
+  /** Build a summary message for inter-agent communication */
+  buildSummaryMessage(fromAgent: string, result: string): string {
+    const scope = this.scopes.get(fromAgent);
+    return JSON.stringify({
+      type: "summary",
+      from: fromAgent,
+      summary: result.slice(0, 500),
+      relevantFiles: scope?.relevantFiles || [],
+    });
+  }
+
+  /** Clear all scopes */
+  clear(): void {
+    this.scopes.clear();
+  }
+}

package/src/control-plane/BudgetController.ts

@@ -0,0 +1,120 @@
+/**
+ * Budget Controller（执行预算控制）
+ * 
+ * 防止 loop 资源失控
+ * 
+ * 限制 per 10 loops:
+ * - max commits: 3
+ * - max file changes: 20
+ * - max API calls: 50
+ * 
+ * 超限处理：
+ * - force pause optimization
+ * - enter evaluation-only mode
+ */
+
+export interface BudgetDecision {
+  allowed: boolean;
+  reason: string;
+  remaining: {
+    commits: number;
+    files: number;
+    apiCalls: number;
+  };
+}
+
+export class BudgetController {
+  private commitHistory: number[] = [];
+  private fileChangeHistory: number[] = [];
+  private apiCallHistory: number[] = [];
+
+  /**
+   * 检查是否在预算内
+   */
+  check(context: {
+    commits: number;
+    filesChanged: number;
+    apiCalls: number;
+    windowSize: number;
+  }): BudgetDecision {
+    // 记录历史
+    this.commitHistory.push(context.commits);
+    this.fileChangeHistory.push(context.filesChanged);
+    this.apiCallHistory.push(context.apiCalls);
+
+    // 计算窗口内的总量
+    const windowCommits = this.sumRecent(this.commitHistory, context.windowSize);
+    const windowFiles = this.sumRecent(this.fileChangeHistory, context.windowSize);
+    const windowApiCalls = this.sumRecent(this.apiCallHistory, context.windowSize);
+
+    // 预算限制
+    const maxCommits = 3;
+    const maxFiles = 20;
+    const maxApiCalls = 50;
+
+    const remaining = {
+      commits: Math.max(0, maxCommits - windowCommits),
+      files: Math.max(0, maxFiles - windowFiles),
+      apiCalls: Math.max(0, maxApiCalls - windowApiCalls)
+    };
+
+    // 检查是否超限
+    if (windowCommits >= maxCommits) {
+      return {
+        allowed: false,
+        reason: `Commit budget exceeded: ${windowCommits}/${maxCommits} in last ${context.windowSize} loops`,
+        remaining
+      };
+    }
+
+    if (windowFiles >= maxFiles) {
+      return {
+        allowed: false,
+        reason: `File change budget exceeded: ${windowFiles}/${maxFiles} in last ${context.windowSize} loops`,
+        remaining
+      };
+    }
+
+    if (windowApiCalls >= maxApiCalls) {
+      return {
+        allowed: false,
+        reason: `API call budget exceeded: ${windowApiCalls}/${maxApiCalls} in last ${context.windowSize} loops`,
+        remaining
+      };
+    }
+
+    return {
+      allowed: true,
+      reason: "Within budget",
+      remaining
+    };
+  }
+
+  /**
+   * 计算最近N项的总和
+   */
+  private sumRecent(history: number[], n: number): number {
+    const recent = history.slice(-n);
+    return recent.reduce((a, b) => a + b, 0);
+  }
+
+  /**
+   * 重置历史
+   */
+  reset(): void {
+    this.commitHistory = [];
+    this.fileChangeHistory = [];
+    this.apiCallHistory = [];
+  }
+
+  /**
+   * 获取历史
+   */
+  getHistory(): { commits: number[]; files: number[]; apiCalls: number[] } {
+    return {
+      commits: [...this.commitHistory],
+      files: [...this.fileChangeHistory],
+      apiCalls: [...this.apiCallHistory]
+    };
+  }
+}